kiosapi 0.1.0

package/dist/api.js

@@ -0,0 +1,202 @@
+import { loadConfig } from './config.js';
+import { dim } from './ui.js';
+/** Turn an upstream HTTP status into an actionable Indonesian message. */
+function humanizeError(status) {
+    if (status === 401)
+        return 'Otorisasi ditolak. Jalankan: kiosapi masuk';
+    if (status === 402)
+        return 'Saldo habis. Isi saldo: kiosapi isi <jumlah> (atau kiosapi.id/dashboard/topup).';
+    if (status === 429)
+        return 'Terlalu banyak permintaan / kuota gratis habis. Coba lagi nanti.';
+    if (status === 404)
+        return 'Model tidak ditemukan. Lihat daftar: kiosapi model';
+    return `Permintaan gagal (HTTP ${status}).`;
+}
+/** GET /v1/models — public, no auth needed. */
+export async function fetchModels() {
+    const { baseUrl } = loadConfig();
+    const res = await fetch(`${baseUrl}/v1/models`);
+    if (!res.ok)
+        throw new Error(`Gagal mengambil daftar model (HTTP ${res.status}).`);
+    const body = (await res.json());
+    return body.data ?? [];
+}
+/** Pick the model to use: explicit flag → configured default → first free text model. */
+export async function resolveModel(flag) {
+    if (flag)
+        return flag;
+    const { defaultModel } = loadConfig();
+    if (defaultModel)
+        return defaultModel;
+    const models = await fetchModels();
+    const text = models.filter((m) => (m.kind ?? 'text') === 'text');
+    const pick = text.find((m) => m.tier === 'free') ?? text[0] ?? models[0];
+    if (!pick)
+        throw new Error('Tidak ada model tersedia di server.');
+    process.stderr.write(`${dim(`(model otomatis: ${pick.id} — atur tetap dengan: kiosapi setel model <id>)`)}\n`);
+    return pick.id;
+}
+/** Authenticated request to the gateway with a humanized error on failure. */
+async function authedFetch(path, init) {
+    const { baseUrl, apiKey } = loadConfig();
+    if (!apiKey)
+        throw new Error('Belum masuk. Jalankan: kiosapi masuk');
+    const res = await fetch(`${baseUrl}${path}`, {
+        ...init,
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            ...init?.headers,
+        },
+    });
+    if (!res.ok)
+        throw new Error(humanizeError(res.status));
+    return res;
+}
+/** GET /v1/saldo — own balance summary. */
+export async function fetchSaldo() {
+    return (await authedFetch('/v1/saldo')).json();
+}
+/** GET /v1/pemakaian — own usage summary over the last N days. */
+export async function fetchPemakaian(days) {
+    return (await authedFetch(`/v1/pemakaian?hari=${days}`)).json();
+}
+/** POST /v1/topup — create a hosted-checkout invoice; returns its URL. */
+export async function createTopup(amount) {
+    const res = await authedFetch('/v1/topup', { method: 'POST', body: JSON.stringify({ amount }) });
+    return res.json();
+}
+/** POST /v1/chat/completions (non-stream) with tools — returns the assistant message (for the agent). */
+export async function chatComplete(model, messages, tools) {
+    const { baseUrl, apiKey } = loadConfig();
+    if (!apiKey)
+        throw new Error('Belum masuk. Jalankan: kiosapi masuk');
+    const res = await fetch(`${baseUrl}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            'X-Title': 'kiosapi-cli',
+        },
+        body: JSON.stringify({
+            model,
+            messages,
+            tools,
+            tool_choice: tools && tools.length > 0 ? 'auto' : undefined,
+            stream: false,
+        }),
+    });
+    if (!res.ok)
+        throw new Error(humanizeError(res.status));
+    const body = (await res.json());
+    const msg = body.choices?.[0]?.message;
+    if (!msg)
+        throw new Error('Respons model kosong.');
+    return { content: msg.content ?? null, tool_calls: msg.tool_calls };
+}
+/** Parse an OpenAI SSE stream, yielding content deltas. */
+async function* consumeSSE(res) {
+    if (!res.body)
+        throw new Error('Respons kosong dari server.');
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('data:'))
+                continue;
+            const payload = trimmed.slice(5).trim();
+            if (payload === '[DONE]')
+                return;
+            try {
+                const evt = JSON.parse(payload);
+                const piece = evt.choices?.[0]?.delta?.content;
+                if (piece)
+                    yield piece;
+            }
+            catch {
+                // ignore keep-alive / non-JSON lines
+            }
+        }
+    }
+}
+/** POST /v1/chat/completions (stream) — yields content chunks as they arrive. */
+export async function* streamChat(model, messages) {
+    const res = await authedFetch('/v1/chat/completions', {
+        method: 'POST',
+        headers: { 'X-Title': 'kiosapi-cli' },
+        body: JSON.stringify({ model, messages, stream: true }),
+    });
+    yield* consumeSSE(res);
+}
+/** Stream a vision question over a local image (sent as a data URL). */
+export async function* streamVision(model, dataUrl, question) {
+    const messages = [
+        {
+            role: 'user',
+            content: [
+                { type: 'text', text: question },
+                { type: 'image_url', image_url: { url: dataUrl } },
+            ],
+        },
+    ];
+    const res = await authedFetch('/v1/chat/completions', {
+        method: 'POST',
+        headers: { 'X-Title': 'kiosapi-cli' },
+        body: JSON.stringify({ model, messages, stream: true }),
+    });
+    yield* consumeSSE(res);
+}
+/** Pick the first model of a given media kind (or honor an explicit flag). */
+export async function resolveMediaModel(flag, kind) {
+    if (flag)
+        return flag;
+    const models = await fetchModels();
+    const m = models.find((x) => x.kind === kind);
+    if (!m)
+        throw new Error(`Tidak ada model ${kind} tersedia. Lihat: kiosapi model`);
+    return m.id;
+}
+/** POST /v1/images/generations — returns the first image (base64) + cost. */
+export async function generateImage(model, prompt, opts = {}) {
+    const res = await authedFetch('/v1/images/generations', {
+        method: 'POST',
+        body: JSON.stringify({ model, prompt, ...opts }),
+    });
+    const body = (await res.json());
+    const first = body.data?.[0];
+    if (!first)
+        throw new Error('Tidak ada gambar yang dihasilkan.');
+    return { b64: first.b64_json, mime: first.mime, cost: body.kiosapi?.cost_rupiah ?? 0 };
+}
+/** POST /v1/videos/generations — submit an async job. */
+export async function submitVideo(model, prompt, opts = {}) {
+    const res = await authedFetch('/v1/videos/generations', {
+        method: 'POST',
+        body: JSON.stringify({ model, prompt, ...opts }),
+    });
+    const body = (await res.json());
+    if (!body.job_id)
+        throw new Error('Gagal memulai job video.');
+    return { jobId: body.job_id, estimate: body.estimate_rupiah ?? 0 };
+}
+/** GET /v1/jobs/:id — poll an async job. */
+export async function pollJob(id) {
+    const res = await authedFetch(`/v1/jobs/${id}`);
+    return (await res.json());
+}
+/** Fetch bytes from an authenticated absolute URL (e.g. a job's video_url). */
+export async function fetchBytesAuthed(url) {
+    const { apiKey } = loadConfig();
+    const res = await fetch(url, { headers: { Authorization: `Bearer ${apiKey}` } });
+    if (!res.ok)
+        throw new Error(humanizeError(res.status));
+    return new Uint8Array(await res.arrayBuffer());
+}

package/dist/commands.js

@@ -0,0 +1,432 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { extname } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { parseArgs } from 'node:util';
+import { runAgent } from './agent/run.js';
+import { runTeam } from './agent/team.js';
+import { createTopup, fetchBytesAuthed, fetchModels, fetchPemakaian, fetchSaldo, generateImage, pollJob, resolveMediaModel, resolveModel, streamChat, streamVision, submitVideo, } from './api.js';
+import { clearKey, fileConfig, loadConfig, saveConfig } from './config.js';
+import { bold, cyan, dim, green, idn, promptHidden, readStdin, red, rupiah, sleep, thinking, yellow, } from './ui.js';
+const IMAGE_MIME = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+};
+/** masuk — store the API key. */
+export async function cmdMasuk() {
+    console.log(dim('Buat API key di https://kiosapi.id/dashboard/keys, lalu tempel di sini.'));
+    const key = (await promptHidden('API key: ')).trim();
+    if (!key)
+        throw new Error('Dibatalkan.');
+    if (!key.startsWith('kios_live_')) {
+        console.error(yellow('Peringatan: API key Kiosapi biasanya diawali "kios_live_".'));
+    }
+    saveConfig({ apiKey: key });
+    console.log(green('✓ Tersimpan di ~/.kiosapi/config.json'));
+    console.log(dim('Coba: kiosapi tanya "halo"'));
+}
+/** keluar — forget the stored key. */
+export function cmdKeluar() {
+    clearKey();
+    console.log(green('✓ Keluar — API key dihapus dari config.'));
+}
+/** periksa — connectivity + settings overview. */
+export async function cmdPeriksa() {
+    const cfg = loadConfig();
+    console.log(bold('Periksa Kiosapi CLI'));
+    console.log(`  Base URL     : ${cfg.baseUrl}`);
+    console.log(`  API key      : ${cfg.apiKey ? green('terpasang') : yellow('belum ada → kiosapi masuk')}`);
+    console.log(`  Model default: ${cfg.defaultModel ?? dim('(otomatis)')}`);
+    process.stdout.write('  Konektivitas : ');
+    try {
+        const res = await fetch(`${cfg.baseUrl}/v1/models`);
+        console.log(res.ok ? green(`OK (${res.status})`) : red(`gagal (${res.status})`));
+    }
+    catch {
+        console.log(red('tidak terhubung'));
+    }
+}
+/** model — list available models (optionally filtered). */
+export async function cmdModel(args) {
+    const { values } = parseArgs({
+        args,
+        options: { cari: { type: 'string', short: 'c' } },
+        allowPositionals: true,
+    });
+    const q = (values.cari ?? '').toLowerCase();
+    const models = await fetchModels();
+    const rows = q
+        ? models.filter((m) => m.id.toLowerCase().includes(q) || (m.provider ?? '').toLowerCase().includes(q))
+        : models;
+    if (rows.length === 0) {
+        console.log(dim('Tidak ada model yang cocok.'));
+        return;
+    }
+    const width = Math.min(42, Math.max(...rows.map((m) => m.id.length)));
+    for (const m of rows) {
+        const tier = (m.tier ?? '').padEnd(5);
+        const kind = (m.kind ?? 'text').padEnd(5);
+        console.log(`${m.id.padEnd(width)}  ${dim(tier)} ${kind} ${dim(m.provider ?? '')}`);
+    }
+    console.log(dim(`\n${rows.length} model.`));
+}
+/** tanya — one-shot streaming question (also reads piped stdin as context). */
+export async function cmdTanya(args) {
+    const { values, positionals } = parseArgs({
+        args,
+        options: { model: { type: 'string', short: 'm' } },
+        allowPositionals: true,
+    });
+    let text = positionals.join(' ').trim();
+    const piped = await readStdin();
+    if (piped)
+        text = text ? `${text}\n\n${piped}` : piped;
+    if (!text)
+        throw new Error('Beri pertanyaan. Contoh: kiosapi tanya "halo"');
+    const model = await resolveModel(values.model);
+    const stop = thinking();
+    let first = true;
+    for await (const piece of streamChat(model, [{ role: 'user', content: text }])) {
+        if (first) {
+            stop();
+            first = false;
+        }
+        process.stdout.write(piece);
+    }
+    if (first)
+        stop();
+    process.stdout.write('\n');
+}
+/** ngobrol — interactive REPL with conversation history. */
+export async function cmdNgobrol(args) {
+    const { values } = parseArgs({
+        args,
+        options: { model: { type: 'string', short: 'm' } },
+        allowPositionals: false,
+    });
+    let model = await resolveModel(values.model);
+    const history = [];
+    console.log(dim(`Mode ngobrol — model ${model}. Perintah: /model <id>, /bersih, /keluar.`));
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        while (true) {
+            const input = (await rl.question(cyan('› '))).trim();
+            if (!input)
+                continue;
+            if (input === '/keluar' || input === '/exit')
+                break;
+            if (input === '/bersih') {
+                history.length = 0;
+                console.log(dim('Riwayat dibersihkan.'));
+                continue;
+            }
+            if (input.startsWith('/model')) {
+                const id = input.split(/\s+/)[1];
+                if (id) {
+                    model = id;
+                    console.log(dim(`Model: ${model}`));
+                }
+                else {
+                    console.log(dim(`Model saat ini: ${model}`));
+                }
+                continue;
+            }
+            history.push({ role: 'user', content: input });
+            let answer = '';
+            const stop = thinking();
+            let first = true;
+            try {
+                for await (const piece of streamChat(model, history)) {
+                    if (first) {
+                        stop();
+                        first = false;
+                    }
+                    process.stdout.write(piece);
+                    answer += piece;
+                }
+                if (first)
+                    stop();
+                process.stdout.write('\n');
+                history.push({ role: 'assistant', content: answer });
+            }
+            catch (err) {
+                if (first)
+                    stop();
+                history.pop();
+                console.error(red(err instanceof Error ? err.message : String(err)));
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+/** setel — read/write persisted settings. */
+export function cmdSetel(args) {
+    const [key, ...rest] = args;
+    if (!key) {
+        console.log(JSON.stringify(fileConfig(), null, 2));
+        return;
+    }
+    const value = rest.join(' ').trim();
+    if (!value)
+        throw new Error('Beri nilai. Contoh: kiosapi setel model deepseek/deepseek-v3');
+    if (key === 'model' || key === 'model-default')
+        saveConfig({ defaultModel: value });
+    else if (key === 'base-url' || key === 'url')
+        saveConfig({ baseUrl: value });
+    else
+        throw new Error(`Kunci tidak dikenal: ${key} (gunakan: model | base-url)`);
+    console.log(green(`✓ ${key} = ${value}`));
+}
+/** Shared driver for the agent modes (rencana/edit/buat). */
+async function runAgentCommand(args, mode) {
+    const { values, positionals } = parseArgs({
+        args,
+        options: { model: { type: 'string', short: 'm' }, otomatis: { type: 'boolean' } },
+        allowPositionals: true,
+    });
+    const task = positionals.join(' ').trim();
+    if (!task)
+        throw new Error('Beri tugas. Contoh: kiosapi buat "bikin REST API Express + tes"');
+    const model = await resolveModel(values.model);
+    await runAgent(task, mode, { model, otomatis: Boolean(values.otomatis) });
+}
+/** rencana — read-only: explore the codebase and produce a plan. */
+export function cmdRencana(args) {
+    return runAgentCommand(args, 'rencana');
+}
+/** edit — make the requested code changes (write/edit, no shell). */
+export function cmdEdit(args) {
+    return runAgentCommand(args, 'edit');
+}
+/** buat — autonomous agent: build/modify the project (write + run). */
+export function cmdBuat(args) {
+    return runAgentCommand(args, 'buat');
+}
+/** gambar — generate an image and save it to a file. */
+export async function cmdGambar(args) {
+    const { values, positionals } = parseArgs({
+        args,
+        options: {
+            model: { type: 'string', short: 'm' },
+            opsi: { type: 'string' },
+            rasio: { type: 'string' },
+            keluar: { type: 'string', short: 'o' },
+        },
+        allowPositionals: true,
+    });
+    const prompt = positionals.join(' ').trim();
+    if (!prompt)
+        throw new Error('Beri prompt. Contoh: kiosapi gambar "kucing astronot"');
+    const model = await resolveMediaModel(values.model, 'image');
+    console.log(dim(`Membuat gambar (${model})…`));
+    const img = await generateImage(model, prompt, {
+        option: values.opsi,
+        aspect_ratio: values.rasio,
+    });
+    const ext = img.mime.includes('jpeg') ? 'jpg' : img.mime.includes('webp') ? 'webp' : 'png';
+    const file = values.keluar ?? `kiosapi-${Date.now()}.${ext}`;
+    writeFileSync(file, Buffer.from(img.b64, 'base64'));
+    console.log(`${green(`✓ ${file}`)} ${dim(`(${rupiah(img.cost)})`)}`);
+}
+/** video — generate a video (async job), poll, and save it. */
+export async function cmdVideo(args) {
+    const { values, positionals } = parseArgs({
+        args,
+        options: {
+            model: { type: 'string', short: 'm' },
+            opsi: { type: 'string' },
+            rasio: { type: 'string' },
+            detik: { type: 'string' },
+            keluar: { type: 'string', short: 'o' },
+        },
+        allowPositionals: true,
+    });
+    const prompt = positionals.join(' ').trim();
+    if (!prompt)
+        throw new Error('Beri prompt. Contoh: kiosapi video "ombak pantai senja"');
+    const model = await resolveMediaModel(values.model, 'video');
+    const duration = values.detik ? Number(values.detik) : undefined;
+    console.log(dim(`Memulai job video (${model})…`));
+    const { jobId, estimate } = await submitVideo(model, prompt, {
+        option: values.opsi,
+        aspect_ratio: values.rasio,
+        duration_seconds: duration,
+    });
+    console.log(dim(`Job ${jobId} — estimasi ${rupiah(estimate)}. Memproses`));
+    for (let i = 0; i < 120; i++) {
+        await sleep(5000);
+        const st = await pollJob(jobId);
+        if (st.status === 'succeeded' && st.video_url) {
+            const bytes = await fetchBytesAuthed(st.video_url);
+            const file = values.keluar ?? `kiosapi-${Date.now()}.mp4`;
+            writeFileSync(file, bytes);
+            const cost = st.cost_rupiah != null ? ` (${rupiah(st.cost_rupiah)})` : '';
+            console.log(`\n${green(`✓ ${file}`)}${dim(cost)}`);
+            return;
+        }
+        if (st.status === 'failed')
+            throw new Error(`\n${st.error ?? 'Video gagal dibuat.'}`);
+        process.stdout.write('.');
+    }
+    throw new Error('\nTimeout menunggu video. Cek lagi nanti dengan job id.');
+}
+/** lihat — ask a vision model about a local image. */
+export async function cmdLihat(args) {
+    const { values, positionals } = parseArgs({
+        args,
+        options: { model: { type: 'string', short: 'm' } },
+        allowPositionals: true,
+    });
+    const file = positionals[0];
+    if (!file)
+        throw new Error('Beri file gambar. Contoh: kiosapi lihat foto.png "apa ini?"');
+    const question = positionals.slice(1).join(' ').trim() || 'Jelaskan gambar ini.';
+    const mime = IMAGE_MIME[extname(file).toLowerCase()] ?? 'image/png';
+    const dataUrl = `data:${mime};base64,${readFileSync(file).toString('base64')}`;
+    const model = await resolveModel(values.model);
+    const stop = thinking();
+    let first = true;
+    for await (const piece of streamVision(model, dataUrl, question)) {
+        if (first) {
+            stop();
+            first = false;
+        }
+        process.stdout.write(piece);
+    }
+    if (first)
+        stop();
+    process.stdout.write('\n');
+}
+/** tim — multi-agent pipeline (perencana → pengkode → peninjau). */
+export async function cmdTim(args) {
+    const { values, positionals } = parseArgs({
+        args,
+        options: { model: { type: 'string', short: 'm' }, otomatis: { type: 'boolean' } },
+        allowPositionals: true,
+    });
+    const task = positionals.join(' ').trim();
+    if (!task)
+        throw new Error('Beri tugas. Contoh: kiosapi tim "bikin endpoint /health + tes"');
+    const model = await resolveModel(values.model);
+    await runTeam(task, { model, otomatis: Boolean(values.otomatis) });
+}
+/** saldo — show own balance, bonus tokens, and month-to-date spend. */
+export async function cmdSaldo() {
+    const s = await fetchSaldo();
+    console.log(`${bold('Saldo')}        : ${green(rupiah(s.balance_rupiah))}`);
+    console.log(`Bonus token  : ${idn(s.bonus_tokens)}`);
+    const cap = s.monthly_cap_rupiah != null ? ` / batas ${rupiah(s.monthly_cap_rupiah)}` : '';
+    console.log(`Bulan ini    : ${rupiah(s.month_spend_rupiah)}${dim(cap)}`);
+}
+/** pakai — usage summary over the last N days (default 30). */
+export async function cmdPakai(args) {
+    const { values } = parseArgs({
+        args,
+        options: { hari: { type: 'string' } },
+        allowPositionals: true,
+    });
+    const days = Math.max(1, Number(values.hari ?? '30') || 30);
+    const p = await fetchPemakaian(days);
+    console.log(bold(`Pemakaian ${p.hari} hari terakhir`));
+    console.log(`  Request : ${idn(p.requests)}`);
+    console.log(`  Token   : ${idn(p.tokens_input + p.tokens_output)} ${dim(`(${idn(p.tokens_input)} in / ${idn(p.tokens_output)} out)`)}`);
+    console.log(`  Biaya   : ${rupiah(p.cost_rupiah)}`);
+    if (p.top_model.length > 0) {
+        console.log(dim('  Model teratas:'));
+        for (const m of p.top_model) {
+            console.log(`    ${m.model}  ${dim(`${idn(m.requests)}×`)} ${rupiah(m.cost_rupiah)}`);
+        }
+    }
+}
+/** isi — create a top-up invoice and print the checkout URL. */
+export async function cmdIsi(args) {
+    const amount = Number(args[0]);
+    if (!Number.isFinite(amount) || amount < 10000) {
+        throw new Error('Jumlah minimal Rp10.000. Contoh: kiosapi isi 50000');
+    }
+    const { invoice_url } = await createTopup(Math.floor(amount));
+    console.log(green(`✓ Tagihan dibuat untuk ${rupiah(amount)}.`));
+    console.log(`Bayar di: ${cyan(invoice_url)}`);
+}
+/** Editor/IDE tools that can't be launched from a terminal — we print paste-config instead. */
+const EDITOR_TOOLS = new Set(['cursor', 'cline', 'continue', 'vscode', 'windsurf']);
+/**
+ * sambung — use Kiosapi inside other OpenAI-compatible agent tools. Either launches a CLI agent
+ * (aider, opencode, …) with the Kiosapi env injected, prints paste-config for editor extensions, or
+ * emits eval-safe shell exports. Only vendor-NEUTRAL tools — first-party vendor agents (Claude Code,
+ * Codex CLI) are intentionally excluded for ToS compliance (see docs/cli-plan.md §13).
+ */
+export function cmdSambung(args) {
+    const sep = args.indexOf('--');
+    const head = sep === -1 ? args : args.slice(0, sep);
+    const forwarded = sep === -1 ? [] : args.slice(sep + 1);
+    const tool = head[0];
+    const { baseUrl, apiKey } = loadConfig();
+    const openaiBase = `${baseUrl}/v1`;
+    if (tool === 'env') {
+        if (!apiKey)
+            throw new Error('Belum masuk. Jalankan: kiosapi masuk');
+        console.log(`export OPENAI_API_KEY='${apiKey}'`);
+        console.log(`export OPENAI_BASE_URL='${openaiBase}'`);
+        console.log(`export OPENAI_API_BASE='${openaiBase}'`);
+        return;
+    }
+    if (!tool) {
+        printSambungHelp(openaiBase);
+        return;
+    }
+    if (!apiKey)
+        throw new Error('Belum masuk. Jalankan: kiosapi masuk');
+    if (EDITOR_TOOLS.has(tool)) {
+        console.log(`${bold(`Setel ${tool} memakai Kiosapi (provider OpenAI-compatible):`)}
+  Base URL / API base : ${openaiBase}
+  API key             : key Kiosapi-mu (kios_live_…)
+  Model               : id model Kiosapi, mis. deepseek/deepseek-v3 (lihat: kiosapi model)
+
+${dim(`Tempel ke setelan "custom/OpenAI-compatible provider" di ${tool}. Jangan bagikan API key.`)}`);
+        return;
+    }
+    // Launch a neutral CLI agent with Kiosapi env injected (stdio inherited so it runs interactively).
+    const res = spawnSync(tool, forwarded, {
+        stdio: 'inherit',
+        shell: process.platform === 'win32',
+        env: {
+            ...process.env,
+            OPENAI_API_KEY: apiKey,
+            OPENAI_BASE_URL: openaiBase,
+            OPENAI_API_BASE: openaiBase,
+        },
+    });
+    if (res.error) {
+        if (res.error.code === 'ENOENT') {
+            throw new Error(`"${tool}" tidak ditemukan di PATH. Pasang dulu lalu coba lagi.\n  aider    : pipx install aider-chat\n  opencode : npm i -g opencode-ai`);
+        }
+        throw res.error;
+    }
+    process.exitCode = res.status ?? 0;
+}
+function printSambungHelp(openaiBase) {
+    console.log(`${bold('kiosapi sambung')} — pakai Kiosapi di tool agen lain (OpenAI-compatible)
+
+  Base URL : ${openaiBase}
+  API key  : key Kiosapi-mu (kios_live_…)
+
+${bold('Luncurkan agen CLI dengan env Kiosapi:')}
+  kiosapi sambung aider -- --model openai/deepseek/deepseek-v3
+  kiosapi sambung opencode
+
+${bold('Tool editor (tampilkan cara setel):')}
+  kiosapi sambung cursor
+  kiosapi sambung cline
+  kiosapi sambung continue
+
+${bold('Shell export (tool apa pun):')}
+  eval "$(kiosapi sambung env)"
+
+${dim('Hanya tool netral OpenAI-compatible. Agen first-party vendor sengaja tidak disertakan (kepatuhan ToS).')}`);
+}

package/dist/config.js

@@ -0,0 +1,49 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const DEFAULT_BASE_URL = 'https://api.kiosapi.id';
+const DIR = join(homedir(), '.kiosapi');
+export const CONFIG_PATH = join(DIR, 'config.json');
+/** Read only the on-disk config (ignores env overrides) — used before writing. */
+function readFile() {
+    if (!existsSync(CONFIG_PATH))
+        return {};
+    try {
+        return JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+    }
+    catch {
+        return {}; // corrupt file → treat as empty
+    }
+}
+/** Effective config: env vars override the file (handy for CI / one-off use). */
+export function loadConfig() {
+    const file = readFile();
+    return {
+        apiKey: process.env.KIOSAPI_API_KEY ?? file.apiKey,
+        baseUrl: process.env.KIOSAPI_BASE_URL ?? file.baseUrl ?? DEFAULT_BASE_URL,
+        defaultModel: file.defaultModel,
+    };
+}
+/** Merge a patch into the on-disk config and persist it (chmod 600 where supported). */
+export function saveConfig(patch) {
+    const next = { ...readFile(), ...patch };
+    mkdirSync(DIR, { recursive: true });
+    writeFileSync(CONFIG_PATH, `${JSON.stringify(next, null, 2)}\n`);
+    try {
+        chmodSync(CONFIG_PATH, 0o600);
+    }
+    catch {
+        // not supported on Windows — ignore
+    }
+}
+/** Forget the stored API key (keeps other settings). */
+export function clearKey() {
+    const file = readFile();
+    file.apiKey = undefined;
+    mkdirSync(DIR, { recursive: true });
+    writeFileSync(CONFIG_PATH, `${JSON.stringify(file, null, 2)}\n`);
+}
+/** The raw on-disk config (for `setel` with no args). */
+export function fileConfig() {
+    return readFile();
+}