sleev 0.0.0 → 0.0.10

package/dist/auth/schema.js

@@ -0,0 +1,46 @@
+// Validation for the browser-to-CLI auth handoff payload.
+export function parseHandoff(input) {
+    if (!isRecord(input))
+        throw new Error('Login callback payload must be an object.');
+    const state = stringField(input, 'state');
+    const token = stringField(input, 'token');
+    const label = nullableStringField(input, 'label');
+    const proxyUrl = stringField(input, 'proxyUrl');
+    if (!state)
+        throw new Error('Login callback state is missing.');
+    if (!token.startsWith('slv_live_'))
+        throw new Error('Login callback token is invalid.');
+    validateUrl(proxyUrl, 'Login callback proxy URL');
+    return { state, token, label, proxyUrl };
+}
+function stringField(input, key) {
+    const value = input[key];
+    if (typeof value !== 'string')
+        throw new Error(`${key} must be a string.`);
+    return value;
+}
+function nullableStringField(input, key) {
+    const value = input[key];
+    if (value === null || typeof value === 'undefined')
+        return null;
+    if (typeof value !== 'string')
+        throw new Error(`${key} must be a string or null.`);
+    return value;
+}
+function validateUrl(raw, name) {
+    const url = parseUrl(raw, name);
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw new Error(`${name} must use http or https.`);
+    }
+}
+function parseUrl(raw, name) {
+    try {
+        return new URL(raw);
+    }
+    catch {
+        throw new Error(`${name} must be a valid URL.`);
+    }
+}
+function isRecord(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}

package/dist/auth/validation.js

@@ -0,0 +1,27 @@
+// Auth validation owns Sleeve token checks against the proxy.
+export async function validateAuth(auth) {
+    const base = trim(auth.proxyUrl);
+    try {
+        const res = await fetch(`${base}/messages`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                'sleeve-token': auth.token,
+                'sleeve-provider': 'anthropic',
+                'sleeve-harness': 'claude-code',
+            },
+            body: '{}',
+        });
+        if (res.status === 401)
+            return 'invalid';
+        if (res.status === 400)
+            return 'valid';
+    }
+    catch {
+        return 'unknown';
+    }
+    return 'unknown';
+}
+function trim(url) {
+    return url.replace(/\/+$/, '');
+}

package/dist/cli.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+// Thin command dispatcher for the `sleev` executable.
+import { existsSync, realpathSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { loginCommand, logoutCommand } from './auth/command.js';
+import { failure } from './terminal.js';
+const HELP = `sleev\n\nUsage:\n  sleev login [--force]\n  sleev install [--force]\n  sleev auth login [--force]\n  sleev auth <command>\n\nCommands:\n  login          Open the Sleev web app when needed and store a local auth token\n  install        Alias for login\n  auth login     Open the Sleev web app when needed and store a local auth token\n  auth logout    Delete the local auth file\n`;
+const LOGIN_HELP = `Usage:\n  sleev login [--force]\n  sleev install [--force]\n  sleev auth login [--force]\n`;
+const AUTH_HELP = `Usage:\n  sleev auth login [--force]\n  sleev auth logout\n`;
+export async function main(argv = process.argv.slice(2)) {
+    if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    if (argv[0] === 'login' || argv[0] === 'install') {
+        if (argv[1] === '--help' || argv[1] === '-h') {
+            process.stdout.write(LOGIN_HELP);
+            return 0;
+        }
+        return login(argv[0], argv.slice(1), LOGIN_HELP);
+    }
+    if (argv[0] !== 'auth') {
+        process.stderr.write(`Unknown command: ${argv[0]}\n\n${HELP}`);
+        return 1;
+    }
+    if (argv[1] === '--help' || argv[1] === '-h') {
+        process.stdout.write(AUTH_HELP);
+        return 0;
+    }
+    const command = argv[1];
+    if (command !== 'login' && command !== 'logout') {
+        process.stderr.write(`Unknown auth command: ${command ?? ''}\n\n${AUTH_HELP}`);
+        return 1;
+    }
+    if (command === 'logout') {
+        if (argv.length !== 2)
+            return usageError(`auth ${command} does not accept flags yet.`, AUTH_HELP);
+        return logoutCommand();
+    }
+    return login(`auth ${command}`, argv.slice(2), AUTH_HELP);
+}
+function login(command, flags, help) {
+    if (flags.some((flag) => flag !== '--force'))
+        return usageError(`Unknown ${command} flag.`, help);
+    return loginCommand({ force: flags.includes('--force') });
+}
+function usageError(message, help) {
+    process.stderr.write(`${message}\n\n${help}`);
+    return 1;
+}
+if (isEntry()) {
+    main().then((code) => {
+        process.exitCode = code;
+    }, (err) => {
+        const message = err instanceof Error ? err.message : 'Command failed.';
+        failure(process.stderr, message);
+        process.exitCode = 1;
+    });
+}
+function isEntry() {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    if (import.meta.url === pathToFileURL(entry).href)
+        return true;
+    if (!existsSync(entry))
+        return false;
+    return realpathSync(new URL(import.meta.url)) === realpathSync(entry);
+}

package/dist/credentials/index.js

@@ -0,0 +1,3 @@
+// Public credential storage API.
+export { authPath, clearAuth, readAuth, writeAuth } from './store.js';
+export { createAuthFile, parseAuthInput } from './schema.js';

package/dist/credentials/schema.js

@@ -0,0 +1,63 @@
+// Validation for the on-disk Sleev auth file.
+export function createAuthFile(input) {
+    const parsed = parseAuthInput(input);
+    return { version: 1, ...parsed };
+}
+export function parseAuthInput(input) {
+    if (!isRecord(input))
+        throw new Error('Sleev auth input must be an object.');
+    return parseAuthRecord(input);
+}
+export function parseAuthFile(input) {
+    if (!isRecord(input))
+        throw new Error('Sleev auth file must be an object.');
+    const version = input.version;
+    if (version !== 1)
+        throw new Error('Sleev auth file version is unsupported.');
+    return { version, ...parseAuthInput(input) };
+}
+function parseAuthRecord(input) {
+    if (!isRecord(input))
+        throw new Error('Sleev auth input must be an object.');
+    const token = stringField(input, 'token');
+    const label = nullableStringField(input, 'label');
+    const proxyUrl = stringField(input, 'proxyUrl');
+    const createdAt = stringField(input, 'createdAt');
+    if (!token.startsWith('slv_live_'))
+        throw new Error('Sleev auth token is invalid.');
+    validateUrl(proxyUrl, 'Sleev auth proxy URL');
+    if (Number.isNaN(Date.parse(createdAt)))
+        throw new Error('Sleev auth createdAt is invalid.');
+    return { token, label, proxyUrl, createdAt };
+}
+function stringField(input, key) {
+    const value = input[key];
+    if (typeof value !== 'string')
+        throw new Error(`${key} must be a string.`);
+    return value;
+}
+function nullableStringField(input, key) {
+    const value = input[key];
+    if (value === null || typeof value === 'undefined')
+        return null;
+    if (typeof value !== 'string')
+        throw new Error(`${key} must be a string or null.`);
+    return value;
+}
+function validateUrl(raw, name) {
+    const url = parseUrl(raw, name);
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw new Error(`${name} must use http or https.`);
+    }
+}
+function parseUrl(raw, name) {
+    try {
+        return new URL(raw);
+    }
+    catch {
+        throw new Error(`${name} must be a valid URL.`);
+    }
+}
+function isRecord(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}

package/dist/credentials/store.js

@@ -0,0 +1,52 @@
+// Credential storage owns auth.json path resolution, validation, and safe writes.
+import { chmod, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { parseAuthFile } from './schema.js';
+export function authPath(env = process.env, platform = process.platform) {
+    return join(configRoot(env, platform), 'sleev', 'auth.json');
+}
+export async function readAuth(path = authPath()) {
+    try {
+        const raw = await readFile(path, 'utf8');
+        return parseAuthFile(JSON.parse(raw));
+    }
+    catch (err) {
+        if (errorCode(err) === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+export async function writeAuth(auth, path = authPath()) {
+    const checked = parseAuthFile(auth);
+    const dir = dirname(path);
+    const tmp = join(dir, `.auth.${process.pid}.${Date.now()}.tmp`);
+    const body = `${JSON.stringify(checked, null, 2)}\n`;
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeFile(tmp, body, { mode: 0o600 });
+    await rename(tmp, path);
+    await chmod(path, 0o600);
+    return { path };
+}
+export async function clearAuth(path = authPath()) {
+    try {
+        await rm(path);
+    }
+    catch (err) {
+        if (errorCode(err) === 'ENOENT')
+            return;
+        throw err;
+    }
+}
+function configRoot(env, platform) {
+    if (platform === 'win32') {
+        return env.APPDATA || join(homedir(), 'AppData', 'Roaming');
+    }
+    return env.XDG_CONFIG_HOME || join(homedir(), '.config');
+}
+function errorCode(err) {
+    if (typeof err !== 'object' || err === null || !('code' in err))
+        return undefined;
+    const code = err.code;
+    return typeof code === 'string' ? code : undefined;
+}

package/dist/harnesses.js

@@ -0,0 +1,66 @@
+// Harness orchestration owns setup and cleanup across supported local tools.
+import { setupClaude, unpatchClaude } from './apps/claude.js';
+import { setupCodex, unpatchCodex } from './apps/codex.js';
+import { availableOpenCodeProviders, setupOpenCode, unpatchOpenCode } from './apps/opencode.js';
+export const HARNESSES = [
+    {
+        id: 'opencode',
+        label: 'opencode',
+        command: 'opencode',
+        available: async () => {
+            try {
+                return (await availableOpenCodeProviders()).length > 0;
+            }
+            catch {
+                return false;
+            }
+        },
+        setup: setupOpenCode,
+        unpatch: unpatchOpenCode,
+    },
+    {
+        id: 'claude-code',
+        label: 'claude code',
+        command: 'claude',
+        setup: setupClaude,
+        unpatch: unpatchClaude,
+    },
+    {
+        id: 'codex',
+        label: 'codex',
+        command: 'codex',
+        setup: setupCodex,
+        unpatch: unpatchCodex,
+    },
+];
+export async function setupHarnesses(auth, apps) {
+    for (const harness of HARNESSES) {
+        if (!apps.includes(harness.id))
+            continue;
+        await harness.setup(auth);
+    }
+    return { label: harnessLabels(apps) };
+}
+export async function unpatchHarnesses() {
+    const failures = [];
+    await Promise.all(HARNESSES.map(async (harness) => {
+        try {
+            await harness.unpatch();
+        }
+        catch (err) {
+            failures.push(`${harness.label}: ${message(err)}`);
+        }
+    }));
+    return { failures };
+}
+export function harnessLabels(ids) {
+    if (ids.length === 0)
+        return 'none';
+    const labels = ids.map((id) => HARNESSES.find((harness) => harness.id === id)?.label ?? id);
+    return labels.join(', ');
+}
+function message(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}

package/dist/index.js

@@ -0,0 +1,3 @@
+// Public package API for programmatic callers.
+export { login } from './auth/index.js';
+export { authPath, clearAuth, createAuthFile, parseAuthInput, readAuth, writeAuth } from './credentials/index.js';

package/dist/product.js

@@ -0,0 +1,27 @@
+// Product defaults and environment escape hatches for local development.
+const DEFAULT_WEB_ORIGIN = 'https://sleev.ai';
+const DEFAULT_PROXY_URL = 'https://api.sleev.ai';
+export function webOrigin(env = process.env) {
+    const raw = env.SLEEV_WEB_ORIGIN?.trim();
+    if (!raw)
+        return DEFAULT_WEB_ORIGIN;
+    const url = parseUrl(raw, 'SLEEV_WEB_ORIGIN');
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw new Error('SLEEV_WEB_ORIGIN must use http or https.');
+    }
+    if (url.pathname !== '/' || url.search || url.hash) {
+        throw new Error('SLEEV_WEB_ORIGIN must be an origin without a path.');
+    }
+    return url.origin;
+}
+export function proxyUrl() {
+    return DEFAULT_PROXY_URL;
+}
+function parseUrl(raw, name) {
+    try {
+        return new URL(raw);
+    }
+    catch {
+        throw new Error(`${name} must be a valid URL.`);
+    }
+}

package/dist/providers.js

@@ -0,0 +1,30 @@
+// Provider registry owns Sleev support metadata shared across harness adapters.
+export const PROVIDERS = [
+    { id: 'openai', label: 'OpenAI' },
+    { id: 'anthropic', label: 'Anthropic' },
+    {
+        id: 'opencode',
+        label: 'OpenCode Zen',
+        models: [
+            'claude-sonnet-4-5',
+            'claude-sonnet-4-6',
+            'claude-opus-4-5',
+            'claude-opus-4-6',
+            'claude-opus-4-7',
+            'gpt-5.3-codex',
+            'gpt-5.3-codex-spark',
+            'gpt-5.4',
+            'gpt-5.4-mini',
+            'gpt-5.4-nano',
+            'gpt-5.4-pro',
+            'gpt-5.5',
+            'gpt-5.5-pro',
+        ],
+    },
+];
+export function provider(id) {
+    const value = PROVIDERS.find((item) => item.id === id);
+    if (!value)
+        throw new Error(`Unsupported provider: ${id}`);
+    return value;
+}

package/dist/terminal.js

@@ -0,0 +1,55 @@
+// Terminal presentation helpers keep command output consistent without deps.
+const styles = {
+    accent: ['\x1b[36m', '\x1b[39m'],
+    bold: ['\x1b[1m', '\x1b[22m'],
+    dim: ['\x1b[2m', '\x1b[22m'],
+    good: ['\x1b[32m', '\x1b[39m'],
+    bad: ['\x1b[31m', '\x1b[39m'],
+};
+export function brand(output) {
+    line(output, paint(output, 'accent', 'sleev'));
+    line(output);
+}
+export function step(output, text) {
+    line(output, `${paint(output, 'accent', '>')} ${text}`);
+}
+export function success(output, text) {
+    line(output, `${paint(output, 'good', 'OK')} ${text}`);
+}
+export function failure(output, text) {
+    line(output, `${paint(output, 'bad', 'ERR')} ${text}`);
+}
+export function note(output, text) {
+    line(output, paint(output, 'dim', text));
+}
+export function field(output, name, value) {
+    line(output, `  ${paint(output, 'dim', name.padEnd(10))} ${value}`);
+}
+export function choice(output, label, active) {
+    if (!active)
+        return `  ${label}`;
+    return `${paint(output, 'accent', '>')} ${paint(output, 'bold', label)}`;
+}
+export function prompt(output, text) {
+    return `${paint(output, 'accent', '?')} ${text} `;
+}
+export function inlineCode(output, value) {
+    return paint(output, 'bold', value);
+}
+export function line(output, text = '') {
+    output.write(`${text}\n`);
+}
+function paint(output, style, text) {
+    if (!color(output))
+        return text;
+    const [open, close] = styles[style];
+    return `${open}${text}${close}`;
+}
+function color(output) {
+    const stream = output;
+    if (process.env.NO_COLOR)
+        return false;
+    if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== '0')
+        return true;
+    return stream.isTTY === true;
+}

package/package.json

@@ -1,10 +1,40 @@
 {
   "name": "sleev",
-  "version": "0.0.0",
-  "description": "Reserved package placeholder.",
-  "license": "MIT",
-  "main": "index.js",
+  "version": "0.0.10",
+  "description": "Sleev command-line tools.",
+  "type": "module",
+  "bin": {
+    "sleev": "dist/cli.js"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
   "files": [
-    "index.js"
-  ]
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "dev": "npm run build && node dist/cli.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "sleev",
+    "cli",
+    "auth"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.2",
+    "typescript": "~6.0.2"
+  },
+  "dependencies": {
+    "jsonc-parser": "^3.3.1"
+  }
 }

package/index.js

@@ -1 +0,0 @@
-"use strict";