@yuiseki/gyazocli 0.0.2 → 0.1.1

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,37 @@ 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)
 
 ## Development
 
@@ -45,6 +95,12 @@ npm install
 npm run build
 ```
 
+### Test
+
+```bash
+npm test
+```
+
 ### 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/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>');

package/dist/index.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeImageId = normalizeImageId;
+exports.normalizeCollectionId = normalizeCollectionId;
 const commander_1 = require("commander");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -13,10 +15,123 @@ const credentials_1 = require("./credentials");
 const program = new commander_1.Command();
 const UPLOAD_DESC_TAG = '#gyazocli_uploads';
 const WEEKDAY_LABELS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const IMAGE_ID_PATTERN = /^[0-9a-f]{32}$/i;
+const GYAZO_HOST_PATTERN = /(^|\.)gyazo\.com$/i;
+/**
+ * Accept either a bare Gyazo image id (32 hex characters) or any Gyazo URL that
+ * carries one, and return the canonical lowercase id. Returns null otherwise.
+ */
+function normalizeImageId(input) {
+    const trimmed = (input || '').trim();
+    if (!trimmed)
+        return null;
+    if (IMAGE_ID_PATTERN.test(trimmed)) {
+        return trimmed.toLowerCase();
+    }
+    if (!/^https?:\/\//i.test(trimmed)) {
+        return null;
+    }
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (!GYAZO_HOST_PATTERN.test(url.hostname)) {
+        return null;
+    }
+    const segments = url.pathname.split('/').filter(Boolean);
+    const lastSegment = segments[segments.length - 1];
+    if (!lastSegment)
+        return null;
+    // /collections/<id> is a collection, not an image.
+    if (segments[segments.length - 2] === 'collections')
+        return null;
+    const withoutExtension = lastSegment.replace(/\.[a-z0-9]+$/i, '');
+    return IMAGE_ID_PATTERN.test(withoutExtension) ? withoutExtension.toLowerCase() : null;
+}
+const COLLECTION_SORTS = ['added', 'created', 'captured'];
+/**
+ * A collection ID looks exactly like an image ID (32 hex characters), so only
+ * the URL form tells the two apart. `/collections/<id>` is a collection;
+ * `/<id>` is an image.
+ */
+function normalizeCollectionId(input) {
+    const trimmed = (input || '').trim();
+    if (!trimmed)
+        return null;
+    if (IMAGE_ID_PATTERN.test(trimmed)) {
+        return trimmed.toLowerCase();
+    }
+    if (!/^https?:\/\//i.test(trimmed)) {
+        return null;
+    }
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        return null;
+    }
+    if (!GYAZO_HOST_PATTERN.test(url.hostname)) {
+        return null;
+    }
+    const segments = url.pathname.split('/').filter(Boolean);
+    if (segments.length < 2 || segments[segments.length - 2] !== 'collections') {
+        return null;
+    }
+    const withoutExtension = segments[segments.length - 1].replace(/\.[a-z0-9]+$/i, '');
+    return IMAGE_ID_PATTERN.test(withoutExtension) ? withoutExtension.toLowerCase() : null;
+}
+function requireCollectionId(input) {
+    const collectionId = normalizeCollectionId(input);
+    if (!collectionId) {
+        console.error(`Error: '${input}' is not a Gyazo collection ID or URL.`);
+        console.error('Hint: pass a 32-character collection ID or a https://gyazo.com/collections/<id> URL.');
+        process.exit(1);
+    }
+    return collectionId;
+}
+function parseCollectionSort(value) {
+    if (value === undefined || value === null)
+        return 'added';
+    if (COLLECTION_SORTS.includes(String(value))) {
+        return String(value);
+    }
+    console.error(`Error: --sort must be one of ${COLLECTION_SORTS.join(', ')}.`);
+    process.exit(1);
+}
+function collectionSortKey(image, sort) {
+    if (sort === 'captured') {
+        return image?.exif_captured_at || image?.metadata?.exif_normalized?.time || image?.created_at || '';
+    }
+    return image?.created_at || '';
+}
+function sortCollectionImages(images, sort) {
+    if (sort === 'added')
+        return images;
+    // Newest first, matching how `list` presents images.
+    return [...images].sort((a, b) => collectionSortKey(b, sort).localeCompare(collectionSortKey(a, sort)));
+}
+function requireImageId(input) {
+    const imageId = normalizeImageId(input);
+    if (!imageId) {
+        console.error(`Error: '${input}' is not a Gyazo image ID or URL.`);
+        if (normalizeCollectionId(input)) {
+            console.error(`Hint: that looks like a collection. Try \`gyazo collection ${input}\`.`);
+        }
+        else {
+            console.error('Hint: pass a 32-character image ID or a https://gyazo.com/<id> URL.');
+        }
+        process.exit(1);
+    }
+    return imageId;
+}
 program
     .name('gyazo')
     .description('Gyazo Memory CLI for AI Secretary')
-    .version('0.0.2');
+    .version('0.1.1');
 // Config Command
 const configCmd = program.command('config').description('Manage configuration');
 configCmd
@@ -1228,6 +1343,42 @@ async function readStdinBuffer() {
         process.stdin.on('error', reject);
     });
 }
+function printCollectionMarkdown(collection, images) {
+    const lines = [];
+    lines.push('## Gyazo Collection');
+    lines.push('');
+    const name = normalizeText(collection?.name);
+    if (name)
+        lines.push(`- Name: ${name}`);
+    const collectionId = collection?.id;
+    const url = collection?.url || (collectionId ? `https://gyazo.com/collections/${collectionId}` : undefined);
+    if (url)
+        lines.push(`- URL: <${url}>`);
+    const description = normalizeText(collection?.description);
+    if (description)
+        lines.push(`- Description: ${description}`);
+    const owner = normalizeText(collection?.user?.name);
+    if (owner)
+        lines.push(`- Owner: ${owner}`);
+    const total = collection?.total_image_count;
+    const shown = images.length;
+    const truncated = typeof total === 'number' && total > shown;
+    lines.push(`- Images: ${truncated ? `${shown} of ${total}` : shown}`);
+    const updatedAt = normalizeText(collection?.list_updated_at);
+    if (updatedAt)
+        lines.push(`- Updated at: ${formatCreatedAt(updatedAt)}`);
+    console.log(lines.join('\n'));
+    if (truncated) {
+        console.log('');
+        console.log('Note: this endpoint returns only the first 100 images of a collection.');
+    }
+    if (shown > 0) {
+        console.log('');
+        console.log('### Images');
+        console.log('');
+        printListImages(images);
+    }
+}
 function printGetMarkdown(image, ocrDescription, objects = []) {
     const lines = [];
     lines.push('## Gyazo Image');
@@ -1267,7 +1418,7 @@ function printGetMarkdown(image, ocrDescription, objects = []) {
 function summarizeImageForList(img) {
     const domain = extractDomain(normalizeText(img.metadata?.url));
     const cleanedTitle = sanitizeSummaryText(img.metadata?.title, domain);
-    const cleanedDesc = sanitizeSummaryText(img.metadata?.desc, domain);
+    const cleanedDesc = sanitizeSummaryText(img.metadata?.desc ?? img.desc, domain);
     const locationLabel = sanitizeSummaryText(extractImageLocationLabel(img));
     const cleanedAltText = sanitizeSummaryText(img.alt_text);
     let main = '(no title/description)';
@@ -1591,6 +1742,7 @@ program
     }
     catch (error) {
         console.error('Error listing images:', error.message);
+        process.exit(1);
     }
 });
 program
@@ -1611,6 +1763,7 @@ program
             console.error('Error: --ocr and --objects cannot be used together.');
             process.exit(1);
         }
+        imageId = requireImageId(imageId);
         let image = options.cache !== false ? (0, storage_1.loadImageCache)(imageId) : null;
         if (!image) {
             image = await (0, api_1.getImageDetail)(imageId);
@@ -1648,6 +1801,43 @@ program
     }
     catch (error) {
         console.error('Error getting image:', error.message);
+        process.exit(1);
+    }
+});
+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 = requireCollectionId(collectionIdInput);
+    const sort = 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 = await (0, api_1.getCollection)(collectionId, { anonymous: Boolean(options.anonymous) });
+        if (options.json) {
+            console.log(JSON.stringify(collection, null, 2));
+            return;
+        }
+        const images = sortCollectionImages(Array.isArray(collection?.images) ? collection.images : [], sort);
+        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);
     }
 });
 program
@@ -1680,6 +1870,7 @@ program
     }
     catch (error) {
         console.error('Error searching images:', error.message);
+        process.exit(1);
     }
 });
 program
@@ -2067,6 +2258,7 @@ 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)')
@@ -2109,13 +2301,12 @@ program
             desc,
             timestamp,
         });
-        console.log(`URL: ${uploaded.permalink_url}`);
-        console.log(`ID: ${uploaded.image_id}`);
-        if (uploaded.created_at) {
-            console.log(`Created at: ${formatCreatedAt(uploaded.created_at)}`);
+        if (options.json) {
+            console.log(JSON.stringify(uploaded, null, 2));
+        }
+        else {
+            console.log(uploaded.permalink_url);
         }
-        console.log(`App: ${options.app || 'gyazocli'}`);
-        console.log(`Desc: ${desc}`);
     }
     catch (error) {
         console.error('Error uploading image:', error.message);
@@ -2270,4 +2461,42 @@ program
         process.exit(1);
     }
 });
-program.parseAsync(process.argv);
+/**
+ * Let the first argument stand on its own when it is unambiguous:
+ * a Gyazo image ID or URL means `get`, an existing file means `upload`.
+ * Anything else is left to commander so unknown commands still report as such.
+ */
+function expandImplicitCommand(argv) {
+    const args = argv.slice(2);
+    const first = args[0];
+    if (!first || first.startsWith('-')) {
+        return argv;
+    }
+    const knownNames = new Set(['help']);
+    for (const command of program.commands) {
+        knownNames.add(command.name());
+        for (const alias of command.aliases()) {
+            knownNames.add(alias);
+        }
+    }
+    if (knownNames.has(first)) {
+        return argv;
+    }
+    let implicitCommand = null;
+    if (normalizeImageId(first)) {
+        // A bare 32-hex ID is ambiguous; treat it as an image.
+        implicitCommand = 'get';
+    }
+    else if (normalizeCollectionId(first)) {
+        // Only the /collections/<id> URL form is unambiguous.
+        implicitCommand = 'collection';
+    }
+    else if (fs_1.default.existsSync(first) && fs_1.default.statSync(first).isFile()) {
+        implicitCommand = 'upload';
+    }
+    if (!implicitCommand) {
+        return argv;
+    }
+    return [...argv.slice(0, 2), implicitCommand, ...args];
+}
+program.parseAsync(expandImplicitCommand(process.argv));

package/docs/ADR/003-cli-structure.md

@@ -11,7 +11,7 @@ Adopt and document the existing top-level command structure.
 
 ### 1. Program Metadata
 - Binary name: `gyazo`
-- Version: `0.0.2`
+- Version: `0.1.1`
 - Description: `Gyazo Memory CLI for AI Secretary`
 
 ### 2. Commands

package/package.json

@@ -1,7 +1,15 @@
 {
   "name": "@yuiseki/gyazocli",
-  "version": "0.0.2",
+  "version": "0.1.1",
   "description": "Gyazo Memory CLI for AI Secretary",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yuiseki/gyazocli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yuiseki/gyazocli/issues"
+  },
+  "homepage": "https://github.com/yuiseki/gyazocli#readme",
   "main": "dist/index.js",
   "bin": {
     "gyazo": "dist/index.js"
@@ -31,6 +39,7 @@
     "axios": "^1.13.5",
     "commander": "^14.0.3",
     "dotenv": "^17.3.1",
+    "form-data": "^4.0.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {