sleev 0.0.0 → 0.0.11

package/README.md

@@ -1,3 +1,49 @@
 # sleev
 
-Reserved package placeholder.
+The Sleev command-line tool.
+
+Use it to sign in to Sleev from your terminal and connect supported local apps.
+
+## Login
+
+Run:
+
+```bash
+npx sleev auth login
+```
+
+Sleev will:
+
+1. Open your browser.
+2. Ask you to sign in or create an account.
+3. Return you to the terminal after login.
+4. Ask which supported local apps you want to use with Sleev.
+
+After that, your local apps can use Sleev without logging in again.
+
+## Logout
+
+Run:
+
+```bash
+npx sleev auth logout
+```
+
+This removes your local Sleev login from this machine.
+
+## Already Logged In
+
+If you need to replace your current local login, run:
+
+```bash
+npx sleev auth login --force
+```
+
+## Requirements
+
+- Node.js 20 or newer
+- A browser you can sign in with
+
+## Notes
+
+Your login is stored locally on your machine. Do not share your Sleev auth file.

package/dist/apps/claude.js

@@ -0,0 +1,151 @@
+// Claude Code setup owns global settings patching for the Anthropic-compatible proxy.
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { field, success } from '../terminal.js';
+const BASE = 'ANTHROPIC_BASE_URL';
+const CUSTOM = 'ANTHROPIC_CUSTOM_HEADERS';
+const HARNESS = 'claude code';
+const OLD_HARNESS = 'claude-code';
+export async function setupClaude(auth, path = claudePath()) {
+    const result = await patchClaude(auth, path);
+    success(process.stdout, 'Configured Claude Code');
+    field(process.stdout, 'config', result.path);
+    return result;
+}
+export async function patchClaude(auth, path = claudePath()) {
+    const existing = await readJson(path);
+    const config = patchConfig(existing, auth);
+    await writeJson(path, config);
+    return { path };
+}
+export async function unpatchClaude(path = claudePath()) {
+    const existing = await readExistingJson(path);
+    if (!existing)
+        return;
+    const env = object(existing.env);
+    if (typeof env.ANTHROPIC_CUSTOM_HEADERS !== 'string')
+        return;
+    if (!patched(env))
+        return;
+    await writeJson(path, removeBackup({ ...existing, env: restoreEnv(env, backup(existing)) }));
+}
+export function claudePath(env = process.env) {
+    return join(env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'), 'settings.json');
+}
+function patchConfig(input, auth) {
+    const env = object(input.env);
+    const previous = backup(input) ?? backupEnv(env);
+    return {
+        ...withBackup(input, previous),
+        env: {
+            ...env,
+            [BASE]: trim(auth.proxyUrl),
+            [CUSTOM]: headers(auth),
+        },
+    };
+}
+function headers(auth) {
+    return [
+        `sleeve-token: ${auth.token}`,
+        'sleeve-provider: anthropic',
+        `sleeve-harness: ${HARNESS}`,
+    ].join('\n');
+}
+function backup(input) {
+    const sleev = object(input.sleev);
+    const claude = object(sleev.claudeCode);
+    if (!('previousEnv' in claude))
+        return null;
+    return object(claude.previousEnv);
+}
+function backupEnv(env) {
+    if (patched(env))
+        return {};
+    const previous = {};
+    if (BASE in env)
+        previous[BASE] = env[BASE];
+    if (CUSTOM in env)
+        previous[CUSTOM] = env[CUSTOM];
+    return previous;
+}
+function withBackup(input, previous) {
+    const sleev = object(input.sleev);
+    return {
+        ...input,
+        sleev: {
+            ...sleev,
+            claudeCode: {
+                previousEnv: previous,
+            },
+        },
+    };
+}
+function removeBackup(input) {
+    const sleev = object(input.sleev);
+    const { claudeCode: _claude, ...rest } = sleev;
+    if (Object.keys(rest).length > 0)
+        return { ...input, sleev: rest };
+    const { sleev: _sleev, ...config } = input;
+    return config;
+}
+function restoreEnv(env, previous) {
+    const { [BASE]: _base, [CUSTOM]: _headers, ...rest } = env;
+    const restored = { ...rest };
+    if (!previous)
+        return restored;
+    if (BASE in previous)
+        restored[BASE] = previous[BASE];
+    if (CUSTOM in previous)
+        restored[CUSTOM] = previous[CUSTOM];
+    return restored;
+}
+function patched(env) {
+    const value = env[CUSTOM];
+    if (typeof value !== 'string')
+        return false;
+    return value.includes(`sleeve-harness: ${HARNESS}`) || value.includes(`sleeve-harness: ${OLD_HARNESS}`);
+}
+async function writeJson(path, config) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+    await chmod(path, 0o600);
+}
+async function readJson(path) {
+    try {
+        const raw = await readFile(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        return object(parsed);
+    }
+    catch (err) {
+        if (code(err) === 'ENOENT')
+            return {};
+        throw err;
+    }
+}
+async function readExistingJson(path) {
+    try {
+        const raw = await readFile(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        return object(parsed);
+    }
+    catch (err) {
+        if (code(err) === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+function object(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return {};
+    return value;
+}
+function trim(url) {
+    return url.replace(/\/+$/, '');
+}
+function code(err) {
+    if (typeof err !== 'object' || err === null || !('code' in err))
+        return undefined;
+    const value = err.code;
+    return typeof value === 'string' ? value : undefined;
+}

package/dist/apps/codex.js

@@ -0,0 +1,184 @@
+// Codex setup owns global TOML patching for the OpenAI-compatible proxy provider.
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { field, success } from '../terminal.js';
+export async function setupCodex(auth, path = codexPath()) {
+    const result = await patchCodex(auth, path);
+    success(process.stdout, 'Configured Codex');
+    field(process.stdout, 'config', result.path);
+    return result;
+}
+export async function patchCodex(auth, path = codexPath()) {
+    const existing = await readText(path);
+    const config = patchCodexConfig(existing, auth);
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, config, { mode: 0o600 });
+    return { path };
+}
+export async function unpatchCodex(path = codexPath()) {
+    const existing = await readText(path);
+    if (!existing)
+        return;
+    const config = unpatchCodexConfig(existing);
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, config, { mode: 0o600 });
+}
+export function codexPath(env = process.env) {
+    return join(env.CODEX_HOME || join(homedir(), '.codex'), 'config.toml');
+}
+export function patchCodexConfig(input, auth) {
+    const provider = rootString(input, 'model_provider') ?? 'openai';
+    const target = reserved(provider) ? 'sleev' : provider;
+    const stale = removeTable(input.trimEnd(), 'model_providers.sleev');
+    const clean = target === provider ? stale : removeRootKey(stale, 'model_provider');
+    const root = target === provider ? clean : insertRootKey(clean.trimEnd(), 'model_provider', target);
+    const base = trim(auth.proxyUrl);
+    return `${patchProvider(root, target, auth, base).trimEnd()}\n`;
+}
+export function unpatchCodexConfig(input) {
+    const provider = rootString(input, 'model_provider') ?? 'openai';
+    const clean = removeTable(removeRootKey(input.trimEnd(), 'model_provider'), 'model_providers.sleev');
+    const config = provider === 'sleev' ? clean : removeSleevKeys(input, provider);
+    return `${config.trimEnd()}\n`;
+}
+function insertRootKey(input, key, value) {
+    const line = `${key} = "${toml(value)}"`;
+    if (input.length === 0)
+        return line;
+    const lines = input.split('\n');
+    const index = lines.findIndex((item) => /^\s*\[/.test(item));
+    if (index === -1)
+        return `${input}\n${line}`;
+    return [...lines.slice(0, index), line, '', ...lines.slice(index)].join('\n');
+}
+function removeRootKey(input, key) {
+    const lines = input.split('\n');
+    const next = [];
+    let root = true;
+    let skipped = false;
+    for (const line of lines) {
+        if (/^\s*\[/.test(line))
+            root = false;
+        if (root && new RegExp(`^\\s*${escape(key)}\\s*=`).test(line)) {
+            skipped = true;
+            continue;
+        }
+        if (skipped && root && /^\s*$/.test(line)) {
+            skipped = false;
+            continue;
+        }
+        skipped = false;
+        next.push(line);
+    }
+    return next.join('\n');
+}
+function removeTable(input, table) {
+    const lines = input.split('\n');
+    const next = [];
+    let skip = false;
+    const header = new RegExp(`^\\s*\\[\\s*${escape(table)}(?:\\.|\\s*\\])`);
+    for (const line of lines) {
+        if (header.test(line)) {
+            skip = true;
+            continue;
+        }
+        if (skip && /^\s*\[/.test(line))
+            skip = header.test(line);
+        if (!skip)
+            next.push(line);
+    }
+    return next.join('\n');
+}
+function patchProvider(input, provider, auth, url) {
+    const table = `model_providers.${provider}`;
+    const clean = removeTable(input, `${table}.http_headers`);
+    const lines = clean.split('\n');
+    const header = new RegExp(`^\\s*\\[\\s*${escape(table)}\\s*\\]\\s*(#.*)?$`);
+    const index = lines.findIndex((line) => header.test(line));
+    const keys = providerKeys(auth, url);
+    if (index === -1)
+        return `${clean.trimEnd()}\n\n[${table}]\nname = "Sleev"\n${keys.join('\n')}`;
+    const next = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? '';
+        const inside = i > index && !/^\s*\[/.test(line);
+        if (inside && /^\s*(base_url|wire_api|http_headers)\s*=/.test(line))
+            continue;
+        next.push(line);
+        if (i === index)
+            next.push(...keys);
+    }
+    return next.join('\n');
+}
+function providerKeys(auth, url) {
+    return [
+        `base_url = "${toml(url)}"`,
+        'wire_api = "responses"',
+        `http_headers = { "sleeve-token" = "${toml(auth.token)}", "sleeve-provider" = "openai", "sleeve-harness" = "codex" }`,
+    ];
+}
+function removeSleevKeys(input, provider) {
+    const table = `model_providers.${provider}`;
+    const lines = input.split('\n');
+    const header = new RegExp(`^\\s*\\[\\s*${escape(table)}\\s*\\]\\s*(#.*)?$`);
+    const index = lines.findIndex((line) => header.test(line));
+    if (index === -1)
+        return input;
+    const current = [];
+    for (let i = index + 1; i < lines.length; i += 1) {
+        const line = lines[i] ?? '';
+        if (/^\s*\[/.test(line))
+            break;
+        current.push(line);
+    }
+    if (!current.some((line) => line.includes('"sleeve-harness" = "codex"')))
+        return input;
+    return lines
+        .filter((line, i) => {
+        const inside = i > index && !/^\s*\[/.test(line);
+        if (!inside)
+            return true;
+        return !/^\s*(base_url|wire_api|http_headers)\s*=/.test(line);
+    })
+        .join('\n');
+}
+function rootString(input, key) {
+    const lines = input.split('\n');
+    for (const line of lines) {
+        if (/^\s*\[/.test(line))
+            return null;
+        const match = new RegExp(`^\\s*${escape(key)}\\s*=\\s*([\"'])([^\"']+)\\1`).exec(line);
+        if (match?.[2])
+            return match[2];
+    }
+    return null;
+}
+function reserved(provider) {
+    return provider === 'openai' || provider === 'ollama' || provider === 'lmstudio';
+}
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (err) {
+        if (code(err) === 'ENOENT')
+            return '';
+        throw err;
+    }
+}
+function toml(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+}
+function escape(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function trim(url) {
+    return url.replace(/\/+$/, '');
+}
+function code(err) {
+    if (typeof err !== 'object' || err === null || !('code' in err))
+        return undefined;
+    const value = err.code;
+    return typeof value === 'string' ? value : undefined;
+}

package/dist/apps/opencode-config.js

@@ -0,0 +1,268 @@
+// OpenCode config ownership picks the active config file and edits its provider state.
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { applyEdits, modify, parse } from 'jsonc-parser';
+import { provider as registryProvider } from '../providers.js';
+export async function patchOpenCodeConfig(auth, path, provider = 'openai') {
+    const target = path ?? (await resolveOpenCodePath());
+    const existing = await readJson(target);
+    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+    if (jsoncPath(target)) {
+        const raw = await readRaw(target);
+        await writeFile(target, patchJsonc(raw, existing, auth, provider), { mode: 0o600 });
+        return target;
+    }
+    const config = patchConfig(existing, auth, provider);
+    await writeFile(target, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+    return target;
+}
+export async function unpatchOpenCodeConfig(path) {
+    const target = path ?? (await resolveOpenCodePath());
+    const existing = await readExistingJson(target);
+    if (!existing)
+        return null;
+    const provider = object(existing.provider);
+    const next = unpatchProvider(unpatchOpenCodeZen(provider), 'openai');
+    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+    if (jsoncPath(target)) {
+        const raw = await readRaw(target);
+        await writeFile(target, unpatchJsonc(raw, provider, next), { mode: 0o600 });
+        return target;
+    }
+    await writeFile(target, `${JSON.stringify({ ...existing, provider: next }, null, 2)}\n`, { mode: 0o600 });
+    return target;
+}
+export function openCodePath(env = process.env, platform = process.platform) {
+    return join(openCodeRoot(env, platform), 'opencode.json');
+}
+export function openCodeJsoncPath(env = process.env, platform = process.platform) {
+    return join(openCodeRoot(env, platform), 'opencode.jsonc');
+}
+export function openCodeAuthPath(env = process.env, platform = process.platform) {
+    const root = platform === 'win32'
+        ? join(homedir(), '.local', 'share')
+        : env.XDG_DATA_HOME || join(homedir(), '.local', 'share');
+    return join(root, 'opencode', 'auth.json');
+}
+export async function resolveOpenCodePath(env = process.env, platform = process.platform) {
+    const jsonc = openCodeJsoncPath(env, platform);
+    const json = openCodePath(env, platform);
+    const [jsoncConfig, jsonConfig] = await Promise.all([readExistingJson(jsonc), readExistingJson(json)]);
+    if (hasProvider(jsoncConfig))
+        return jsonc;
+    if (hasProvider(jsonConfig))
+        return json;
+    if (await exists(jsonc))
+        return jsonc;
+    return json;
+}
+function openCodeRoot(env = process.env, platform = process.platform) {
+    const root = platform === 'win32'
+        ? join(homedir(), '.config')
+        : env.XDG_CONFIG_HOME || join(homedir(), '.config');
+    return join(root, 'opencode');
+}
+function patchConfig(input, auth, id) {
+    const provider = object(input.provider);
+    const base = trim(auth.proxyUrl);
+    const next = id === 'opencode' ? patchOpenCodeZen(provider, auth, base) : patchProvider(provider, auth, base, id);
+    return {
+        ...input,
+        provider: next,
+    };
+}
+function patchProvider(provider, auth, base, id) {
+    const existing = object(provider[id]);
+    const options = object(existing.options);
+    const headers = object(options.headers);
+    return {
+        ...provider,
+        [id]: {
+            ...existing,
+            options: {
+                ...options,
+                baseURL: base,
+                headers: {
+                    ...headers,
+                    ...sleeveHeaders(auth, id === 'openai' ? 'codex' : id),
+                },
+            },
+        },
+    };
+}
+function unpatchProvider(provider, id) {
+    const existing = object(provider[id]);
+    const options = object(existing.options);
+    const headers = object(options.headers);
+    if (headers['sleeve-harness'] !== 'opencode')
+        return provider;
+    const { ['sleeve-token']: _token, ['sleeve-provider']: _provider, ['sleeve-harness']: _harness, ...rest } = headers;
+    const { baseURL: _base, ...other } = options;
+    return {
+        ...provider,
+        [id]: {
+            ...existing,
+            options: {
+                ...other,
+                headers: rest,
+            },
+        },
+    };
+}
+function patchOpenCodeZen(provider, auth, base) {
+    const existing = object(provider.opencode);
+    const models = object(existing.models);
+    const registry = registryProvider('opencode');
+    const patched = Object.fromEntries((registry.models ?? []).map((id) => {
+        const model = object(models[id]);
+        const source = object(model.provider);
+        const headers = object(model.headers);
+        return [
+            id,
+            {
+                ...model,
+                provider: {
+                    ...source,
+                    api: base,
+                },
+                headers: {
+                    ...headers,
+                    ...sleeveHeaders(auth, 'opencode'),
+                },
+            },
+        ];
+    }));
+    return {
+        ...provider,
+        opencode: {
+            ...existing,
+            models: {
+                ...models,
+                ...patched,
+            },
+        },
+    };
+}
+function unpatchOpenCodeZen(provider) {
+    const existing = object(provider.opencode);
+    const models = object(existing.models);
+    const patched = Object.fromEntries(Object.entries(models).map(([id, value]) => {
+        const model = object(value);
+        const headers = object(model.headers);
+        if (headers['sleeve-harness'] !== 'opencode')
+            return [id, model];
+        const { ['sleeve-token']: _token, ['sleeve-provider']: _provider, ['sleeve-harness']: _harness, ...rest } = headers;
+        const source = object(model.provider);
+        const { api: _api, ...provider } = source;
+        return [
+            id,
+            {
+                ...model,
+                provider,
+                headers: rest,
+            },
+        ];
+    }));
+    return {
+        ...provider,
+        opencode: {
+            ...existing,
+            models: patched,
+        },
+    };
+}
+function sleeveHeaders(auth, provider) {
+    return {
+        'sleeve-token': auth.token,
+        'sleeve-provider': provider,
+        'sleeve-harness': 'opencode',
+    };
+}
+async function readJson(path) {
+    try {
+        const raw = await readFile(path, 'utf8');
+        const parsed = jsoncPath(path) ? parse(raw, [], { allowTrailingComma: true }) : JSON.parse(raw);
+        return object(parsed);
+    }
+    catch (err) {
+        if (code(err) === 'ENOENT')
+            return {};
+        throw err;
+    }
+}
+async function readExistingJson(path) {
+    try {
+        const raw = await readFile(path, 'utf8');
+        const parsed = jsoncPath(path) ? parse(raw, [], { allowTrailingComma: true }) : JSON.parse(raw);
+        return object(parsed);
+    }
+    catch (err) {
+        if (code(err) === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+async function readRaw(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (err) {
+        if (code(err) === 'ENOENT')
+            return '{}\n';
+        throw err;
+    }
+}
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (err) {
+        if (code(err) === 'ENOENT')
+            return false;
+        throw err;
+    }
+}
+function hasProvider(config) {
+    if (!config)
+        return false;
+    return 'provider' in config && typeof config.provider === 'object' && config.provider !== null && !Array.isArray(config.provider);
+}
+function patchJsonc(raw, existing, auth, id) {
+    const provider = object(existing.provider);
+    const base = trim(auth.proxyUrl);
+    const next = id === 'opencode' ? patchOpenCodeZen(provider, auth, base) : patchProvider(provider, auth, base, id);
+    const key = id === 'opencode' ? 'opencode' : id;
+    const value = next[key];
+    return editJsonc(raw, ['provider', key], value);
+}
+function unpatchJsonc(raw, provider, next) {
+    const openai = object(next.openai);
+    const opencode = object(next.opencode);
+    const target = 'openai' in provider ? editJsonc(raw, ['provider', 'openai'], 'openai' in next ? openai : undefined) : raw;
+    return 'opencode' in provider ? editJsonc(target, ['provider', 'opencode'], 'opencode' in next ? opencode : undefined) : target;
+}
+function editJsonc(raw, path, value) {
+    const edits = modify(raw, path, value, {
+        formattingOptions: { insertSpaces: true, tabSize: 2, keepLines: true, insertFinalNewline: true },
+    });
+    return applyEdits(raw, edits);
+}
+function jsoncPath(path) {
+    return path.endsWith('.jsonc');
+}
+function object(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return {};
+    return value;
+}
+function trim(url) {
+    return url.replace(/\/+$/, '');
+}
+function code(err) {
+    if (typeof err !== 'object' || err === null || !('code' in err))
+        return undefined;
+    const value = err.code;
+    return typeof value === 'string' ? value : undefined;
+}