@hintoai/cli 0.2.0

package/dist/commands/templates.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTemplates = registerTemplates;
+const templates_1 = require("../api/templates");
+const errors_1 = require("../errors");
+const output_1 = require("../output");
+function registerTemplates(program, client) {
+    const templates = program.command('templates').description('Browse templates');
+    const api = (0, templates_1.templatesApi)(client);
+    templates
+        .command('article')
+        .description('List article generation templates for this project type')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        try {
+            const data = await api.articleTemplates();
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printTable)(['ID', 'Name', 'Requires Video', 'Description'], data.templates.map((t) => [
+                String(t.id),
+                t.name,
+                t.requires_video ? 'yes' : 'no',
+                t.description ?? '—',
+            ]));
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    templates
+        .command('structure')
+        .description('List structure generation templates for this project type')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        try {
+            const data = await api.structureTemplates();
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printTable)(['ID', 'Name', 'Requires Video', 'Description'], data.templates.map((t) => [
+                String(t.id),
+                t.name,
+                t.requires_video ? 'yes' : 'no',
+                t.description ?? '—',
+            ]));
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+}

package/dist/commands/videos.d.ts

@@ -0,0 +1,3 @@
+import type { AxiosInstance } from 'axios';
+import type { Command } from 'commander';
+export declare function registerVideos(program: Command, client: AxiosInstance): void;

package/dist/commands/videos.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerVideos = registerVideos;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const axios_1 = __importDefault(require("axios"));
+const videos_1 = require("../api/videos");
+const errors_1 = require("../errors");
+const output_1 = require("../output");
+function registerVideos(program, client) {
+    const videos = program.command('videos').description('Manage videos');
+    const api = (0, videos_1.videosApi)(client);
+    videos
+        .command('list')
+        .description('List all videos')
+        .option('--offset <n>', 'Number of videos to skip', '0')
+        .option('--limit <n>', 'Results per page', '20')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        try {
+            const data = await api.list({ offset: Number(opts.offset), limit: Number(opts.limit) });
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printTable)(['Video ID', 'Filename', 'Status', 'Created'], data.videos.map((v) => [v.videoId, v.filename ?? '—', v.status, v.createdAt]));
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    videos
+        .command('import')
+        .description('Import a video from a URL')
+        .requiredOption('--url <url>', 'Video URL to import')
+        .option('--name <name>', 'Display name for the imported video')
+        .option('--callback-url <url>', 'URL to receive a webhook when the import job completes')
+        .option('--callback-secret <secret>', 'HMAC-SHA256 signing secret for the callback webhook')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        try {
+            const data = await api.import(opts.url, opts.name, opts.callbackUrl, opts.callbackSecret);
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printKeyValue)(data);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    videos
+        .command('get <videoId>')
+        .description('Get a video by ID')
+        .option('--json', 'Output as JSON')
+        .action(async (videoId, opts) => {
+        try {
+            const data = await api.get(videoId);
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printKeyValue)(data);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    videos
+        .command('status <videoId>')
+        .description('Get video processing status')
+        .option('--json', 'Output as JSON')
+        .action(async (videoId, opts) => {
+        try {
+            const data = await api.status(videoId);
+            if (opts.json)
+                return (0, output_1.printJson)(data);
+            (0, output_1.printKeyValue)(data);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    videos
+        .command('delete <videoId>')
+        .description('Delete a video')
+        .option('--json', 'Output as JSON')
+        .action(async (videoId, opts) => {
+        try {
+            await api.delete(videoId);
+            if (opts.json)
+                return (0, output_1.printJson)({ deleted: true });
+            process.stdout.write(`Video ${videoId} deleted.\n`);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+    videos
+        .command('upload')
+        .description('Upload a video file from disk (3-step presigned flow)')
+        .requiredOption('--file <path>', 'Path to the video file')
+        .option('--json', 'Output as JSON')
+        .action(async (opts) => {
+        try {
+            const filePath = path.resolve(opts.file);
+            if (!fs.existsSync(filePath)) {
+                (0, errors_1.exitWithError)(`File not found: ${filePath}`);
+                return;
+            }
+            const filename = path.basename(filePath);
+            const ext = path.extname(filename).toLowerCase();
+            const contentTypeMap = {
+                '.mp4': 'video/mp4',
+                '.mov': 'video/quicktime',
+                '.webm': 'video/webm',
+                '.avi': 'video/avi',
+                '.mkv': 'video/x-matroska',
+            };
+            const contentType = contentTypeMap[ext] ?? 'video/mp4';
+            // Step 1: get presigned URL
+            process.stderr.write('Requesting presigned upload URL...\n');
+            const { videoId, uploadUrl, key: s3Key } = await api.uploadPresigned(filename, contentType);
+            // Step 2: PUT file to S3
+            process.stderr.write(`Uploading ${filename}...\n`);
+            const fileStream = fs.createReadStream(filePath);
+            const { size } = fs.statSync(filePath);
+            await axios_1.default.put(uploadUrl, fileStream, {
+                headers: { 'Content-Type': contentType, 'Content-Length': size },
+                maxBodyLength: Number.POSITIVE_INFINITY,
+                maxContentLength: Number.POSITIVE_INFINITY,
+            });
+            // Step 3: complete upload
+            process.stderr.write('Completing upload...\n');
+            const result = await api.uploadComplete(videoId, s3Key, filename);
+            if (opts.json)
+                return (0, output_1.printJson)(result);
+            process.stdout.write(`Uploaded: videoId=${result.videoId}  status=pending\n`);
+            process.stdout.write(`Track: hinto videos status ${result.videoId}\n`);
+        }
+        catch (e) {
+            (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+        }
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+export interface HintoConfig {
+    apiKey: string;
+    baseUrl: string;
+}
+export declare const CONFIG_PATH: string;
+export declare function saveConfig(config: HintoConfig): void;
+export declare function loadConfig(): HintoConfig;

package/dist/config.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_PATH = void 0;
+exports.saveConfig = saveConfig;
+exports.loadConfig = loadConfig;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+exports.CONFIG_PATH = path_1.default.join(os_1.default.homedir(), '.hinto', 'config.json');
+function saveConfig(config) {
+    const dir = path_1.default.dirname(exports.CONFIG_PATH);
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs_1.default.writeFileSync(exports.CONFIG_PATH, JSON.stringify(config, null, 2), {
+        encoding: 'utf-8',
+        mode: 0o600,
+    });
+}
+function loadConfig() {
+    if (!fs_1.default.existsSync(exports.CONFIG_PATH)) {
+        throw new Error('Run `hinto init --key <your-api-key>` to get started.');
+    }
+    const raw = JSON.parse(fs_1.default.readFileSync(exports.CONFIG_PATH, 'utf-8'));
+    return {
+        ...raw,
+        apiKey: process.env.HINTO_API_KEY ?? raw.apiKey,
+    };
+}

package/dist/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class CliError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare function exitWithError(message: string): never;

package/dist/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliError = void 0;
+exports.exitWithError = exitWithError;
+class CliError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'CliError';
+    }
+}
+exports.CliError = CliError;
+function exitWithError(message) {
+    process.stderr.write(`Error: ${message}\n`);
+    process.exit(1);
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const client_1 = require("./api/client");
+const articles_1 = require("./commands/articles");
+const completion_1 = require("./commands/completion");
+const export_1 = require("./commands/export");
+const folders_1 = require("./commands/folders");
+const generate_1 = require("./commands/generate");
+const init_1 = require("./commands/init");
+const project_1 = require("./commands/project");
+const publish_1 = require("./commands/publish");
+const templates_1 = require("./commands/templates");
+const videos_1 = require("./commands/videos");
+const config_1 = require("./config");
+const errors_1 = require("./errors");
+// Read version from package.json so `hinto --version` never drifts from the
+// published package version (package.json sits one level above dist/index.js).
+const { version } = require('../package.json');
+const program = new commander_1.Command();
+program
+    .name('hinto')
+    .description('Hinto AI CLI — manage videos, articles, and publishing')
+    .version(version)
+    .option('--api-url <url>', 'Override the Hinto base URL');
+// init and completion don't need auth — register first
+(0, init_1.registerInit)(program);
+(0, completion_1.registerCompletion)(program);
+// Load config eagerly. If missing, fall back to empty key so --help still
+// works on all subcommands. The client's interceptor returns a helpful
+// UNAUTHORIZED message when a command is actually invoked without a valid key.
+const config = (() => {
+    try {
+        return (0, config_1.loadConfig)();
+    }
+    catch {
+        return { apiKey: process.env.HINTO_API_KEY ?? '', baseUrl: 'https://app.hinto.ai' };
+    }
+})();
+const apiUrl = (() => {
+    const idx = process.argv.indexOf('--api-url');
+    return idx !== -1 ? (process.argv[idx + 1] ?? config.baseUrl) : config.baseUrl;
+})();
+const client = (0, client_1.createClient)(config.apiKey, apiUrl);
+(0, videos_1.registerVideos)(program, client);
+(0, articles_1.registerArticles)(program, client);
+(0, folders_1.registerFolders)(program, client);
+(0, generate_1.registerGenerate)(program, client);
+(0, project_1.registerProject)(program, client);
+(0, publish_1.registerPublish)(program, client);
+(0, templates_1.registerTemplates)(program, client);
+(0, export_1.registerExport)(program, client);
+program.parseAsync(process.argv).catch((e) => {
+    (0, errors_1.exitWithError)(e instanceof Error ? e.message : String(e));
+});

package/dist/output.d.ts

@@ -0,0 +1,3 @@
+export declare function printJson(data: unknown): void;
+export declare function printTable(headers: string[], rows: string[][]): void;
+export declare function printKeyValue(obj: Record<string, unknown> | unknown): void;

package/dist/output.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printJson = printJson;
+exports.printTable = printTable;
+exports.printKeyValue = printKeyValue;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+function printJson(data) {
+    process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+function printTable(headers, rows) {
+    const table = new cli_table3_1.default({ head: headers.map((h) => chalk_1.default.bold(h)) });
+    rows.forEach((row) => table.push(row));
+    process.stdout.write(`${table.toString()}\n`);
+}
+function printKeyValue(obj) {
+    if (obj == null || typeof obj !== 'object') {
+        process.stdout.write(`${String(obj)}\n`);
+        return;
+    }
+    const lines = Object.entries(obj)
+        .map(([k, v]) => `${chalk_1.default.bold(k)}: ${formatValue(k, v)}`)
+        .join('\n');
+    process.stdout.write(`${lines}\n`);
+}
+function formatValue(key, value) {
+    if ((key === 'status' || key === 'ingest_status') && typeof value === 'string') {
+        if (['ready', 'completed'].includes(value))
+            return chalk_1.default.green(value);
+        if (['pending', 'processing'].includes(value))
+            return chalk_1.default.yellow(value);
+        if (value === 'failed')
+            return chalk_1.default.red(value);
+    }
+    if (value === null || value === undefined)
+        return chalk_1.default.dim('—');
+    if (typeof value === 'object')
+        return JSON.stringify(value, null, 2);
+    return String(value);
+}

package/dist/poll.d.ts

@@ -0,0 +1,2 @@
+import type { AxiosInstance } from 'axios';
+export declare function pollJob(client: AxiosInstance, jobId: string, intervalMs?: number, timeoutMs?: number): Promise<unknown>;

package/dist/poll.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollJob = pollJob;
+async function pollJob(client, jobId, intervalMs = 2000, timeoutMs = 300000) {
+    process.stderr.write(`Waiting for job ${jobId}…\n`);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const { data } = await client.get(`/generate/${jobId}`);
+        if (data.status === 'completed') {
+            process.stderr.write(`Job ${jobId} completed\n`);
+            return data.output;
+        }
+        if (data.status === 'failed') {
+            process.stderr.write(`Job ${jobId} failed\n`);
+            throw new Error(data.error ?? 'Job failed with no error message');
+        }
+        await sleep(intervalMs);
+    }
+    throw new Error(`Job ${jobId} timed out after ${timeoutMs / 1000}s`);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@hintoai/cli",
+  "version": "0.2.0",
+  "description": "Hinto AI CLI — manage videos, articles, and publishing via the Hinto API",
+  "main": "dist/index.js",
+  "bin": {
+    "hinto": "./dist/index.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/hintoai/hinto-cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hintoai/hinto-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hintoai/hinto-cli/issues"
+  },
+  "keywords": [
+    "hinto",
+    "cli",
+    "video",
+    "articles",
+    "publishing",
+    "ai",
+    "agent-skill"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "lint": "biome check .",
+    "format": "biome format --write .",
+    "validate:skill": "node scripts/validate-skill.mjs",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "npm run build && changeset publish",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "axios": "^1.7.0",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "ora": "^8.1.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "1.9.4",
+    "@changesets/cli": "^2.31.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.9.2",
+    "jest": "^30.4.2",
+    "nock": "^13.5.0",
+    "ts-jest": "^29.4.11",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.5.0"
+  }
+}