@yuiseki/gyazocli 0.0.2 → 0.2.0

package/README.md

@@ -16,17 +16,37 @@ gyazo sync --days 10
 gyazo --help
 ```
 
+### Shorthands
+
+The first argument may stand on its own when it is unambiguous. A Gyazo
+image ID is 32 hex characters, so it can never be mistaken for a path.
+
+```bash
+gyazo path/to/image.png                              # same as: gyazo upload path/to/image.png
+gyazo 49a008e2f254f513063b6ec4d3082940               # same as: gyazo get 49a008e2f254f513063b6ec4d3082940
+gyazo https://gyazo.com/49a008e2f254f513063b6ec4d3082940   # same as above
+gyazo https://gyazo.com/collections/21ca16a1023c667a7a437be561a65018  # same as: gyazo collection <id>
+```
+
+A collection ID is 32 hex characters just like an image ID, so a bare ID is read
+as an image. Only the `/collections/<id>` URL form is unambiguous. When a command
+is given the wrong kind of ID it points at the other one.
+
+Subcommand names always win, so `gyazo search` stays `gyazo search` even
+if a file of that name exists in the working directory.
+
 ### Detail
 
 - `gyazo config set token <token>`: Save your access token
 - `gyazo config get token|me`: Show saved token (masked) or `me` profile info
 - `gyazo ls` (`gyazo list`): List images (`--date`/`--today`, `--photos`, `--uploaded`, `-H` available; `--photos/--uploaded` can be combined with `--date`/`--today`)
 - `gyazo search <query>`: Search images
-- `gyazo get <image_id>`: Show image details (`--ocr`, `--objects`, `-j` available)
+- `gyazo collection <collection_id|url>` (`col`, `cols`, `collections`): Show a collection and the images in it (`--sort added|created|captured`, `-A`, `-j` available)
+- `gyazo get <image_id|url>`: Show image details (`--ocr`, `--objects`, `-j` available). Accepts a bare image ID, a `https://gyazo.com/<id>` permalink, or a `https://i.gyazo.com/<id>.png` URL
 - `gyazo apps|domains|tags|locations`: Show rankings
 - `gyazo summary`: Show day-by-day weekly summary in Markdown (`##`/`###` headings, image count, apps, domains, tags, locations per day)
 - `gyazo stats`: Show weekly summary
-- `gyazo upload [path]`: Upload an image (uses stdin when path is omitted)
+- `gyazo upload [path]`: Upload an image (uses stdin when path is omitted). Prints the permalink URL alone; use `-j` for the full response
 - `gyazo sync`: Sync cache
 
 Date range notes:
@@ -34,7 +54,97 @@ Date range notes:
 - Use `--today` for today only, or `--date <yyyy|yyyy-mm|yyyy-mm-dd>` for a custom range
 
 JSON output:
-- `-j, --json` is available for `config get`, `ls`, `get`, `search`, `apps`, `domains`, `tags`, `locations`, and `summary`
+- `-j, --json` is available for `config get`, `ls`, `get`, `search`, `apps`, `domains`, `tags`, `locations`, `summary`, and `upload`
+
+### Anonymous access
+
+A Gyazo ID is long enough to act as the key to the image, so public images and
+collections read fine with no token. An access token, on the other hand, allows
+things this CLI does not expose (deleting, for one), so the way to give an agent
+read-only access is to give it no token at all.
+
+```bash
+gyazo collection <id>               # uses the token if there is one, otherwise reads anonymously
+gyazo collection <id> --anonymous   # ignores the token even when one is configured
+```
+
+Anonymous reads have limits worth knowing:
+
+- A collection or image set to `only_me` returns 404, indistinguishable from one
+  that does not exist. That is deliberate: it keeps the ID from confirming what
+  exists.
+- An image with `metadata_is_public: false` still returns 200, but `metadata` and
+  `created_at` come back `null`, so OCR, EXIF and location are gone. The web
+  endpoint withholds these even from the owner's token; `gyazo get` uses
+  `api.gyazo.com` for that reason.
+
+Exit codes:
+- `0` on success, `1` on a usage error or a failed API call
+
+Environment variables:
+- `GYAZO_ACCESS_TOKEN`: access token (takes precedence over the saved config)
+- `GYAZO_CACHE_DIR`: cache location
+- `GYAZO_API_ORIGIN` / `GYAZO_UPLOAD_ORIGIN` / `GYAZO_WEB_ORIGIN`: override the endpoints (used by the test suite)
+
+## MCP server
+
+`gyazo --mcp-server` runs the CLI as a Model Context Protocol server over
+stdio, so an MCP client can search your captures. `--mcp`, `mcp-server` and
+`mcp` start the same thing.
+
+```bash
+gyazo --mcp-server
+```
+
+It needs an access token before it starts, from `gyazo config set token` or
+from `GYAZO_ACCESS_TOKEN` in the client's environment. stdout carries only
+JSON-RPC; anything meant for a human goes to stderr.
+
+Configured in a client:
+
+```json
+{
+  "mcpServers": {
+    "gyazo": {
+      "command": "npx",
+      "args": ["-y", "@yuiseki/gyazocli", "--mcp-server"],
+      "env": { "GYAZO_ACCESS_TOKEN": "your_access_token" }
+    }
+  }
+}
+```
+
+### Tools
+
+- `gyazo_search`: full-text search over your captures. Arguments: `query`
+  (required, up to 200 characters), `page` (default 1), `per` (default 20,
+  max 100). Search syntax is the same as Gyazo's: `cat`, `title:cat`,
+  `app:"Google Chrome"`, `url:google.com`, `cat since:2024-01-01 until:2024-12-31`.
+- `gyazo_image`: metadata for one capture. Argument: `id_or_url` (required),
+  which accepts a bare 32-character ID, a `https://gyazo.com/<id>` permalink or
+  a direct image URL.
+- `gyazo_latest_image`: metadata for the capture uploaded most recently. No
+  arguments.
+- `gyazo_list`: the captures, newest first, with the same options as
+  `gyazo list`: `page`, `limit`, `date`, `today`, `hour`, `photos`, `uploaded`,
+  `max_pages`, `use_cache`. No arguments means the most recent page.
+- `gyazo_summary`: what a day or a range adds up to, with the same options as
+  `gyazo summary`: `date`, `today`, `limit`, `max_pages`, `use_cache`. No
+  arguments means the week up to yesterday.
+- `gyazo_collection`: a collection and the captures in it. Arguments:
+  `id_or_url` (required) and `sort` (`added`, `created` or `captured`).
+
+All of them are read-only, and all of them return metadata rather than image
+bytes: URLs, timestamp, OCR text, title, source application and page, and
+location when the capture carries one. Use the URLs in a result to show the
+capture itself. Handing base64 image data to a model turned out not to work
+well in practice, and describing a capture does.
+
+Tool names and arguments follow
+[nota/gyazo-mcp-server](https://github.com/nota/gyazo-mcp-server), so a client
+already configured against that server can point at this one instead. Its
+`gyazo_upload` is deliberately absent: nothing here can write to your Gyazo
+account until there is a reason for it to.
 
 ## Development
 
@@ -45,6 +155,17 @@ npm install
 npm run build
 ```
 
+### Test
+
+```bash
+npm test
+```
+
+### Release
+
+Push a `v*` tag and Actions stages the package on npm, where a maintainer
+approves it with 2FA. See [RELEASE.md](RELEASE.md).
+
 ### Link local CLI with npm link
 
 ```bash

package/dist/api.js

@@ -7,18 +7,35 @@ exports.listImages = listImages;
 exports.getImageDetail = getImageDetail;
 exports.searchImages = searchImages;
 exports.getCurrentUser = getCurrentUser;
+exports.getCollection = getCollection;
 exports.uploadImage = uploadImage;
 const axios_1 = __importDefault(require("axios"));
 const form_data_1 = __importDefault(require("form-data"));
 const config_1 = require("./config");
-const API_BASE_URL = 'https://api.gyazo.com/api/images';
-const API_SEARCH_URL = 'https://api.gyazo.com/api/search';
-const API_USERS_ME_URL = 'https://api.gyazo.com/api/users/me';
-const API_UPLOAD_URL = 'https://upload.gyazo.com/api/upload';
-async function requestWithRetry(url, params = {}) {
-    const headers = { Authorization: `Bearer ${config_1.config.GYAZO_ACCESS_TOKEN}` };
+const DEFAULT_API_ORIGIN = 'https://api.gyazo.com';
+const DEFAULT_UPLOAD_ORIGIN = 'https://upload.gyazo.com';
+const DEFAULT_WEB_ORIGIN = 'https://gyazo.com';
+function stripTrailingSlash(origin) {
+    return origin.replace(/\/+$/, '');
+}
+function apiOrigin() {
+    return stripTrailingSlash(config_1.config.GYAZO_API_ORIGIN || DEFAULT_API_ORIGIN);
+}
+function uploadOrigin() {
+    return stripTrailingSlash(config_1.config.GYAZO_UPLOAD_ORIGIN || DEFAULT_UPLOAD_ORIGIN);
+}
+function webOrigin() {
+    return stripTrailingSlash(config_1.config.GYAZO_WEB_ORIGIN || DEFAULT_WEB_ORIGIN);
+}
+const apiBaseUrl = () => `${apiOrigin()}/api/images`;
+const apiSearchUrl = () => `${apiOrigin()}/api/search`;
+const apiUsersMeUrl = () => `${apiOrigin()}/api/users/me`;
+const apiUploadUrl = () => `${uploadOrigin()}/api/upload`;
+const webCollectionUrl = (id) => `${webOrigin()}/collections/${id}.json`;
+async function requestWithRetry(url, params = {}, headers) {
+    const requestHeaders = headers ?? { Authorization: `Bearer ${config_1.config.GYAZO_ACCESS_TOKEN}` };
     try {
-        const response = await axios_1.default.get(url, { headers, params });
+        const response = await axios_1.default.get(url, { headers: requestHeaders, params });
         return response.data;
     }
     catch (error) {
@@ -26,22 +43,35 @@ async function requestWithRetry(url, params = {}) {
             const retryAfter = parseInt(error.response.headers['retry-after'] || '5', 10);
             console.warn(`Rate limited. Retrying after ${retryAfter} seconds...`);
             await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
-            return requestWithRetry(url, params);
+            return requestWithRetry(url, params, headers);
         }
         throw error;
     }
 }
 async function listImages(page = 1, perPage = 20) {
-    return requestWithRetry(API_BASE_URL, { page, per_page: perPage });
+    return requestWithRetry(apiBaseUrl(), { page, per_page: perPage });
 }
 async function getImageDetail(imageId) {
-    return requestWithRetry(`${API_BASE_URL}/${imageId}`);
+    return requestWithRetry(`${apiBaseUrl()}/${imageId}`);
 }
 async function searchImages(query, page = 1, perPage = 20) {
-    return requestWithRetry(API_SEARCH_URL, { query, page, per: perPage });
+    return requestWithRetry(apiSearchUrl(), { query, page, per: perPage });
 }
 async function getCurrentUser() {
-    return requestWithRetry(API_USERS_ME_URL);
+    return requestWithRetry(apiUsersMeUrl());
+}
+/**
+ * Collections are read through the public web endpoint. It returns the
+ * collection metadata plus the first 100 images with their full detail in a
+ * single request, and it works without a token for public collections, which
+ * is what lets an agent run read-only with no credentials at all.
+ */
+async function getCollection(collectionId, options = {}) {
+    const headers = {};
+    if (!options.anonymous && config_1.config.GYAZO_ACCESS_TOKEN) {
+        headers.Authorization = `Bearer ${config_1.config.GYAZO_ACCESS_TOKEN}`;
+    }
+    return requestWithRetry(webCollectionUrl(collectionId), {}, headers);
 }
 async function uploadImage(options) {
     const form = new form_data_1.default();
@@ -60,7 +90,7 @@ async function uploadImage(options) {
     if (typeof options.timestamp === 'number') {
         form.append('created_at', String(options.timestamp));
     }
-    const response = await axios_1.default.post(API_UPLOAD_URL, form, {
+    const response = await axios_1.default.post(apiUploadUrl(), form, {
         headers: form.getHeaders(),
     });
     return response.data;

package/dist/commands/apps.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAppsCommand = registerAppsCommand;
+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 registerAppsCommand(program) {
+    program
+        .command('apps')
+        .description('Rank metadata app names 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 totalWithApp = 0;
+            let totalImages = 0;
+            if (useCache) {
+                let cacheSummary = (0, analytics_1.buildAppsRankingFromHourlyCache)(targetDate);
+                if (cacheSummary.totalImages === 0) {
+                    await (0, memory_1.warmDateCacheForApps)(targetDate, maxPages, true);
+                    cacheSummary = (0, analytics_1.buildAppsRankingFromHourlyCache)(targetDate);
+                }
+                ranking = cacheSummary.ranking;
+                totalWithApp = cacheSummary.imageCountWithApps;
+                totalImages = cacheSummary.totalImages;
+            }
+            else {
+                const imageIds = await (0, memory_1.warmDateCacheForApps)(targetDate, maxPages, false);
+                ranking = (0, analytics_1.buildAppsRankingFromCache)(imageIds);
+                totalWithApp = 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,
+                    app_image_count: totalWithApp,
+                    total_apps: ranking.length,
+                    ranking: displayedRanking,
+                }, null, 2));
+                return;
+            }
+            if (ranking.length === 0) {
+                console.log(`No app metadata found for ${targetDate.dateKey}.`);
+                return;
+            }
+            console.log(`Apps on ${targetDate.dateKey}`);
+            displayedRanking.forEach((item, index) => {
+                console.log(`${index + 1}. ${item.app}: ${item.count}`);
+            });
+            console.log(`Total images with app metadata: ${totalWithApp}`);
+        }
+        catch (error) {
+            console.error('Error ranking apps:', error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/collection.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCollectionCommand = registerCollectionCommand;
+const credentials_1 = require("../credentials");
+const collections_1 = require("../services/collections");
+function registerCollectionCommand(program) {
+    program
+        .command('collection <collection_id>')
+        .aliases(['col', 'cols', 'collections'])
+        .description('Show a collection and the images in it')
+        .option('-j, --json', 'output as JSON')
+        .option('-A, --anonymous', 'read without an access token, even when one is configured')
+        .option('--sort <added|created|captured>', 'image order (default: added)')
+        .action(async (collectionIdInput, options) => {
+        const collectionId = (0, collections_1.requireCollectionId)(collectionIdInput);
+        const sort = (0, collections_1.parseCollectionSort)(options.sort);
+        // No token is not an error here: public collections read fine anonymously.
+        if (!options.anonymous) {
+            (0, credentials_1.resolveAccessToken)();
+        }
+        try {
+            const { collection, images } = await (0, collections_1.readCollection)(collectionId, {
+                anonymous: Boolean(options.anonymous),
+                sort,
+            });
+            if (options.json) {
+                console.log(JSON.stringify(collection, null, 2));
+                return;
+            }
+            (0, collections_1.printCollectionMarkdown)(collection, images);
+        }
+        catch (error) {
+            if (error?.response?.status === 404) {
+                console.error(`Error: collection ${collectionId} was not found or not public.`);
+                console.error('Hint: a private collection returns the same 404 as one that does not exist.');
+                if (options.anonymous) {
+                    console.error('Hint: you are running with --anonymous. Drop it to use your access token.');
+                }
+                process.exit(1);
+            }
+            console.error('Error getting collection:', error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/config.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConfigCommand = registerConfigCommand;
+const api_1 = require("../api");
+const credentials_1 = require("../credentials");
+function registerConfigCommand(program) {
+    const configCmd = program.command('config').description('Manage configuration');
+    configCmd
+        .command('set <key> <value>')
+        .description('Set a configuration value')
+        .action((key, value) => {
+        (0, credentials_1.setStoredConfig)(key, value);
+    });
+    configCmd
+        .command('get <key>')
+        .description('Get a configuration value')
+        .option('-j, --json', 'output as JSON')
+        .action(async (key, options) => {
+        if (key === 'me') {
+            await (0, credentials_1.ensureAccessToken)();
+            try {
+                const me = await (0, api_1.getCurrentUser)();
+                if (options.json) {
+                    console.log(JSON.stringify(me, null, 2));
+                    return;
+                }
+                const user = me?.user || {};
+                if (user.uid)
+                    console.log(`UID: ${user.uid}`);
+                if (user.name)
+                    console.log(`Name: ${user.name}`);
+                if (user.email)
+                    console.log(`Email: ${user.email}`);
+                if (typeof user.is_pro === 'boolean')
+                    console.log(`Plan: ${user.is_pro ? 'Pro' : 'Free'}`);
+                if (typeof user.is_team === 'boolean')
+                    console.log(`Team: ${user.is_team ? 'Yes' : 'No'}`);
+                if (user.profile_image)
+                    console.log(`Profile image: ${user.profile_image}`);
+            }
+            catch (error) {
+                console.error('Error getting current user:', error.message);
+                process.exit(1);
+            }
+            return;
+        }
+        const value = (0, credentials_1.getStoredConfig)(key);
+        if (value) {
+            if (key === 'token') {
+                const masked = value.length > 8
+                    ? `${value.substring(0, 4)}...${value.substring(value.length - 4)}`
+                    : '********';
+                console.log(masked);
+            }
+            else {
+                console.log(value);
+            }
+        }
+        else {
+            console.error(`Config key '${key}' not found.`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/domains.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDomainsCommand = registerDomainsCommand;
+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 registerDomainsCommand(program) {
+    program
+        .command('domains')
+        .description('Rank metadata URL domains 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 totalWithDomain = 0;
+            let totalImages = 0;
+            if (useCache) {
+                let cacheSummary = (0, analytics_1.buildDomainsRankingFromHourlyCache)(targetDate);
+                if (cacheSummary.totalImages === 0) {
+                    await (0, memory_1.warmDateCacheForDomains)(targetDate, maxPages, true);
+                    cacheSummary = (0, analytics_1.buildDomainsRankingFromHourlyCache)(targetDate);
+                }
+                ranking = cacheSummary.ranking;
+                totalWithDomain = cacheSummary.imageCountWithDomains;
+                totalImages = cacheSummary.totalImages;
+            }
+            else {
+                const imageIds = await (0, memory_1.warmDateCacheForDomains)(targetDate, maxPages, false);
+                ranking = (0, analytics_1.buildDomainsRankingFromCache)(imageIds);
+                totalWithDomain = 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,
+                    domain_image_count: totalWithDomain,
+                    total_domains: ranking.length,
+                    ranking: displayedRanking,
+                }, null, 2));
+                return;
+            }
+            if (ranking.length === 0) {
+                console.log(`No domain metadata found for ${targetDate.dateKey}.`);
+                return;
+            }
+            console.log(`Domains on ${targetDate.dateKey}`);
+            displayedRanking.forEach((item, index) => {
+                console.log(`${index + 1}. ${item.domain}: ${item.count}`);
+            });
+            console.log(`Total images with domain metadata: ${totalWithDomain}`);
+        }
+        catch (error) {
+            console.error('Error ranking domains:', error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/get.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGetCommand = registerGetCommand;
+const api_1 = require("../api");
+const storage_1 = require("../storage");
+const credentials_1 = require("../credentials");
+const format_1 = require("../format");
+const memory_1 = require("../services/memory");
+const images_1 = require("../services/images");
+function registerGetCommand(program) {
+    program
+        .command('get <image_id>')
+        .description('Get detailed metadata for an image')
+        .option('-j, --json', 'output as JSON')
+        .option('--ocr', 'output OCR text only')
+        .option('--objects', 'output object annotations only')
+        .option('--no-cache', 'force fetch from API')
+        .action(async (imageId, options) => {
+        await (0, credentials_1.ensureAccessToken)();
+        try {
+            if (options.json && (options.ocr || options.objects)) {
+                console.error('Error: --json cannot be used with --ocr or --objects.');
+                process.exit(1);
+            }
+            if (options.ocr && options.objects) {
+                console.error('Error: --ocr and --objects cannot be used together.');
+                process.exit(1);
+            }
+            imageId = (0, images_1.requireImageId)(imageId);
+            let image = options.cache !== false ? (0, storage_1.loadImageCache)(imageId) : null;
+            if (!image) {
+                image = await (0, api_1.getImageDetail)(imageId);
+                (0, storage_1.saveImageCache)(imageId, image);
+            }
+            const supplemented = (0, memory_1.supplementAltTextFromSearchCache)(image);
+            image = supplemented.image;
+            if (supplemented.supplemented) {
+                (0, storage_1.saveImageCache)(imageId, image);
+            }
+            const ocrDescription = (0, format_1.extractOcrDescription)(image);
+            const objects = (0, format_1.extractObjectAnnotations)(image);
+            if (options.ocr) {
+                if (!ocrDescription) {
+                    console.error('OCR not found for this image.');
+                    process.exit(1);
+                }
+                console.log(ocrDescription);
+                return;
+            }
+            if (options.objects) {
+                if (objects.length === 0) {
+                    console.error('Object annotations not found for this image.');
+                    process.exit(1);
+                }
+                console.log(objects.map(format_1.formatObjectAnnotationLine).join('\n'));
+                return;
+            }
+            if (options.json) {
+                console.log(JSON.stringify(image, null, 2));
+            }
+            else {
+                (0, images_1.printGetMarkdown)(image, ocrDescription, objects);
+            }
+        }
+        catch (error) {
+            console.error('Error getting image:', error.message);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/import.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerImportCommand = registerImportCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const storage_1 = require("../storage");
+function registerImportCommand(program) {
+    program
+        .command('import <type> <dir>')
+        .description('Import legacy data (type: json|hourly)')
+        .action(async (type, dir) => {
+        const sourceDir = path_1.default.resolve(dir);
+        if (!fs_1.default.existsSync(sourceDir)) {
+            console.error(`Error: Source directory ${sourceDir} does not exist.`);
+            process.exit(1);
+        }
+        if (type === 'json') {
+            const targetDir = path_1.default.join((0, storage_1.getCacheDir)(), 'images');
+            console.log(`Importing legacy Gyazo JSON from ${sourceDir}...`);
+            let total = 0;
+            const walk = (d) => {
+                fs_1.default.readdirSync(d, { withFileTypes: true }).forEach(e => {
+                    const p = path_1.default.join(d, e.name);
+                    if (e.isDirectory())
+                        walk(p);
+                    else if (e.name.endsWith('.json')) {
+                        const id = e.name.replace('.json', '');
+                        const p1 = id[0] || '_', p2 = id[1] || '_';
+                        const dest = path_1.default.join(targetDir, p1, p2);
+                        if (!fs_1.default.existsSync(dest))
+                            fs_1.default.mkdirSync(dest, { recursive: true });
+                        fs_1.default.copyFileSync(p, path_1.default.join(dest, e.name));
+                        total++;
+                        if (total % 100 === 0)
+                            process.stdout.write('.');
+                    }
+                });
+            };
+            walk(sourceDir);
+            console.log(`\nImport complete. Copied ${total} files.`);
+        }
+        else if (type === 'hourly') {
+            console.log(`Importing legacy Gyazo hourly data from ${sourceDir}...`);
+            let total = 0;
+            const years = fs_1.default.readdirSync(sourceDir).filter(f => /^[0-9]{4}$/.test(f));
+            for (const y of years) {
+                const months = fs_1.default.readdirSync(path_1.default.join(sourceDir, y)).filter(f => /^[0-9]{2}$/.test(f));
+                for (const m of months) {
+                    const days = fs_1.default.readdirSync(path_1.default.join(sourceDir, y, m)).filter(f => /^[0-9]{2}$/.test(f));
+                    for (const d of days) {
+                        const hours = fs_1.default.readdirSync(path_1.default.join(sourceDir, y, m, d)).filter(f => /^[0-9]{2}$/.test(f));
+                        for (const h of hours) {
+                            const txt = path_1.default.join(sourceDir, y, m, d, h, 'image_ids.txt');
+                            if (fs_1.default.existsSync(txt)) {
+                                const ids = fs_1.default.readFileSync(txt, 'utf-8').split('\n').map(id => id.trim()).filter(id => id.length > 0);
+                                (0, storage_1.saveHourlyCache)(y, m, d, h, ids);
+                                total++;
+                            }
+                        }
+                    }
+                }
+                process.stdout.write('.');
+            }
+            console.log(`\nImport complete. Copied ${total} hourly index files.`);
+        }
+        else {
+            console.error('Error: type must be "json" or "hourly"');
+            process.exit(1);
+        }
+    });
+}