zk-credits 0.1.0 → 0.1.2

package/dist/anthropic-messages.d.ts

@@ -0,0 +1,81 @@
+export interface AnthropicContentBlock {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+export interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: string | AnthropicContentBlock[];
+}
+export interface AnthropicMessagesRequest {
+    model?: string;
+    system?: string | AnthropicContentBlock[];
+    messages: AnthropicMessage[];
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stop_sequences?: string[];
+    stream?: boolean;
+    [key: string]: unknown;
+}
+export interface OpenAiMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface OpenAiChatRequest {
+    model: string;
+    messages: OpenAiMessage[];
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stop?: string[];
+    stream?: boolean;
+    [key: string]: unknown;
+}
+export interface OpenAiChatResponse {
+    id?: string;
+    object?: string;
+    created?: number;
+    model?: string;
+    choices?: Array<{
+        index?: number;
+        message?: {
+            role?: string;
+            content?: string | null;
+        };
+        finish_reason?: string | null;
+    }>;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+    };
+}
+export interface AnthropicMessageResponse {
+    id: string;
+    type: 'message';
+    role: 'assistant';
+    model: string;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | null;
+    stop_sequence: string | null;
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+}
+export declare function anthropicErrorType(status: number): string;
+export declare function translateAnthropicToOpenAi(request: AnthropicMessagesRequest): OpenAiChatRequest;
+export declare function translateOpenAiToAnthropic(response: OpenAiChatResponse): AnthropicMessageResponse;
+export interface StreamTransformerOptions {
+    model: string;
+    id?: string;
+}
+export interface AnthropicStreamTransformer {
+    transformChunk(chunk: unknown): string[];
+    finish(): string[];
+}
+export declare function createAnthropicStreamTransformer(options: StreamTransformerOptions): AnthropicStreamTransformer;

package/dist/anthropic-messages.js

@@ -0,0 +1,192 @@
+function normalizeContent(content) {
+    if (!content)
+        return '';
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((block) => {
+            if (typeof block === 'string')
+                return block;
+            if (block && typeof block.text === 'string')
+                return block.text;
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    return '';
+}
+function resolveModel(requestedModel) {
+    if (!requestedModel)
+        return 'openai/gpt-4o-mini';
+    if (requestedModel.includes('/'))
+        return requestedModel;
+    return 'openai/gpt-4o-mini';
+}
+function mapFinishReason(reason) {
+    if (!reason || reason === 'stop')
+        return 'end_turn';
+    if (reason === 'length')
+        return 'max_tokens';
+    if (reason === 'tool_calls' || reason === 'function_call')
+        return 'tool_use';
+    return 'end_turn';
+}
+export function anthropicErrorType(status) {
+    switch (status) {
+        case 400:
+            return 'invalid_request_error';
+        case 401:
+            return 'authentication_error';
+        case 403:
+            return 'permission_error';
+        case 404:
+            return 'not_found_error';
+        case 413:
+            return 'request_too_large';
+        case 429:
+            return 'rate_limit_error';
+        case 529:
+            return 'overloaded_error';
+        default:
+            return status >= 500 ? 'api_error' : 'invalid_request_error';
+    }
+}
+export function translateAnthropicToOpenAi(request) {
+    const messages = [];
+    const systemContent = normalizeContent(request.system);
+    if (systemContent) {
+        messages.push({ role: 'system', content: systemContent });
+    }
+    for (const msg of request.messages || []) {
+        const content = normalizeContent(msg.content);
+        messages.push({
+            role: msg.role === 'assistant' ? 'assistant' : 'user',
+            content,
+        });
+    }
+    const openAiRequest = {
+        model: resolveModel(request.model),
+        messages,
+    };
+    if (request.max_tokens !== undefined) {
+        openAiRequest.max_tokens = request.max_tokens;
+    }
+    if (request.temperature !== undefined) {
+        openAiRequest.temperature = request.temperature;
+    }
+    if (request.top_p !== undefined) {
+        openAiRequest.top_p = request.top_p;
+    }
+    if (request.stop_sequences && request.stop_sequences.length > 0) {
+        openAiRequest.stop = request.stop_sequences;
+    }
+    if (request.stream) {
+        openAiRequest.stream = true;
+    }
+    return openAiRequest;
+}
+export function translateOpenAiToAnthropic(response) {
+    const choice = response.choices?.[0];
+    const text = choice?.message?.content ?? '';
+    const stopReason = mapFinishReason(choice?.finish_reason);
+    return {
+        id: response.id?.startsWith('msg_')
+            ? response.id
+            : `msg_${response.id || 'zk_' + Date.now()}`,
+        type: 'message',
+        role: 'assistant',
+        model: response.model || 'openai/gpt-4o-mini',
+        content: [{ type: 'text', text }],
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage: {
+            input_tokens: response.usage?.prompt_tokens ?? 0,
+            output_tokens: response.usage?.completion_tokens ?? 0,
+        },
+    };
+}
+export function createAnthropicStreamTransformer(options) {
+    const messageId = options.id || `msg_zk_${Date.now()}`;
+    const model = options.model;
+    let started = false;
+    let blockStarted = false;
+    let blockIndex = 0;
+    let promptTokens = 0;
+    let completionTokens = 0;
+    let finalStopReason = null;
+    function sse(event, data) {
+        return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    }
+    return {
+        transformChunk(rawChunk) {
+            const chunk = rawChunk;
+            const out = [];
+            if (!started) {
+                started = true;
+                out.push(sse('message_start', {
+                    type: 'message_start',
+                    message: {
+                        id: messageId,
+                        type: 'message',
+                        role: 'assistant',
+                        model,
+                        content: [],
+                        stop_reason: null,
+                        stop_sequence: null,
+                        usage: { input_tokens: 0, output_tokens: 0 },
+                    },
+                }));
+            }
+            if (chunk.usage) {
+                if (chunk.usage.prompt_tokens)
+                    promptTokens = chunk.usage.prompt_tokens;
+                if (chunk.usage.completion_tokens)
+                    completionTokens = chunk.usage.completion_tokens;
+            }
+            const choice = chunk.choices?.[0];
+            const deltaContent = choice?.delta?.content;
+            if (deltaContent) {
+                if (!blockStarted) {
+                    blockStarted = true;
+                    out.push(sse('content_block_start', {
+                        type: 'content_block_start',
+                        index: blockIndex,
+                        content_block: { type: 'text', text: '' },
+                    }));
+                }
+                out.push(sse('content_block_delta', {
+                    type: 'content_block_delta',
+                    index: blockIndex,
+                    delta: { type: 'text_delta', text: deltaContent },
+                }));
+            }
+            if (choice?.finish_reason) {
+                finalStopReason = mapFinishReason(choice.finish_reason);
+            }
+            return out;
+        },
+        finish() {
+            const out = [];
+            if (blockStarted) {
+                out.push(sse('content_block_stop', {
+                    type: 'content_block_stop',
+                    index: blockIndex,
+                }));
+            }
+            out.push(sse('message_delta', {
+                type: 'message_delta',
+                delta: {
+                    stop_reason: finalStopReason || 'end_turn',
+                    stop_sequence: null,
+                },
+                usage: { output_tokens: completionTokens },
+            }));
+            out.push(sse('message_stop', {
+                type: 'message_stop',
+            }));
+            return out;
+        },
+    };
+}

package/dist/claude-launcher.d.ts

@@ -0,0 +1,17 @@
+interface SpawnedProcess {
+    once(event: 'error', listener: (error: NodeJS.ErrnoException) => void): this;
+    once(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+}
+export type ClaudeSpawnCommand = (command: string, args: readonly string[], options: {
+    stdio: 'inherit';
+    env: NodeJS.ProcessEnv;
+}) => SpawnedProcess;
+export interface LaunchClaudeOptions {
+    args: readonly string[];
+    loopbackBaseUrl: string;
+    localToken: string;
+    stateDirectory: string;
+}
+/** Configures and launches Claude Code against the proof-aware loopback transport. */
+export declare function launchClaudeProcess(options: LaunchClaudeOptions, spawnImpl?: ClaudeSpawnCommand): Promise<number>;
+export {};

package/dist/claude-launcher.js

@@ -0,0 +1,47 @@
+import { spawn } from 'node:child_process';
+import { chmod, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+const spawnCommand = (command, args, options) => spawn(command, [...args], options);
+function anthropicBaseUrl(loopbackBaseUrl) {
+    const url = new URL(loopbackBaseUrl);
+    if (url.protocol !== 'http:' || url.hostname !== '127.0.0.1') {
+        throw new Error('Claude Code companion must use a 127.0.0.1 HTTP sidecar URL');
+    }
+    // Claude Code appends /v1/messages, so base URL must NOT have trailing /v1
+    return url.origin;
+}
+async function prepareClaudeDirectory(stateDirectory) {
+    const configDirectory = join(stateDirectory, 'claude');
+    await mkdir(configDirectory, { recursive: true, mode: 0o700 });
+    await chmod(configDirectory, 0o700);
+    return configDirectory;
+}
+function waitForClaude(child) {
+    return new Promise((resolve, reject) => {
+        child.once('error', (error) => {
+            if (error.code === 'ENOENT') {
+                reject(new Error('Claude Code CLI was not found; install it with npm install -g @anthropic-ai/claude-code before running zk-credits claude'));
+                return;
+            }
+            reject(error);
+        });
+        child.once('exit', (code) => resolve(code ?? 1));
+    });
+}
+/** Configures and launches Claude Code against the proof-aware loopback transport. */
+export async function launchClaudeProcess(options, spawnImpl = spawnCommand) {
+    const configDirectory = await prepareClaudeDirectory(options.stateDirectory);
+    const baseUrl = anthropicBaseUrl(options.loopbackBaseUrl);
+    const env = {
+        ...process.env,
+        CLAUDE_CONFIG_DIR: configDirectory,
+        ANTHROPIC_BASE_URL: baseUrl,
+        ANTHROPIC_AUTH_TOKEN: options.localToken,
+        DISABLE_TELEMETRY: '1',
+    };
+    const child = spawnImpl('claude', [...options.args], {
+        stdio: 'inherit',
+        env,
+    });
+    return waitForClaude(child);
+}

package/dist/cli-runtime.d.ts

@@ -10,6 +10,8 @@ export interface CliCommandDependencies {
     isCodexProfileInstalled(): Promise<boolean>;
     isSidecarHealthy(): Promise<boolean>;
     launchCodex(args: readonly string[]): Promise<number>;
+    launchCline(args: readonly string[], localToken: string): Promise<number>;
+    launchClaude(args: readonly string[], localToken: string): Promise<number>;
 }
 /** Handles the non-server CLI commands independently from terminal I/O. */
 export declare function runCliCommand(args: readonly string[], dependencies: CliCommandDependencies): Promise<number>;

package/dist/cli-runtime.js

@@ -49,7 +49,23 @@ export async function runCliCommand(args, dependencies) {
             await dependencies.ensureSidecar();
             return dependencies.launchCodex(args.slice(1));
         }
+        case 'cline': {
+            if (!await dependencies.isIdentityConfigured()) {
+                await dependencies.importMnemonic(await dependencies.readMnemonic());
+                dependencies.write('ZK Credits identity imported into the system credential store.');
+            }
+            const localToken = await dependencies.ensureSidecar();
+            return dependencies.launchCline(args.slice(1), localToken);
+        }
+        case 'claude': {
+            if (!await dependencies.isIdentityConfigured()) {
+                await dependencies.importMnemonic(await dependencies.readMnemonic());
+                dependencies.write('ZK Credits identity imported into the system credential store.');
+            }
+            const localToken = await dependencies.ensureSidecar();
+            return dependencies.launchClaude(args.slice(1), localToken);
+        }
         default:
-            throw new Error('Usage: zk-credits <setup codex|codex|status|token|import-mnemonic|serve|env>');
+            throw new Error('Usage: zk-credits <cline|claude|setup codex|codex|status|token|import-mnemonic|serve|env>');
     }
 }

package/dist/cli.js

@@ -2,6 +2,8 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { launchCodexProcess } from './codex-launcher.js';
+import { launchClineProcess } from './cline-launcher.js';
+import { launchClaudeProcess } from './claude-launcher.js';
 import { isCodexProfileInstalled, resolveCodexHome, writeCodexProfile, } from './codex-profile.js';
 import { IdentityStore } from './identity.js';
 import { createLocalProofGenerator } from './local-prover.js';
@@ -77,6 +79,8 @@ async function readHiddenMnemonic() {
 }
 function printHelp() {
     console.log(`Usage:
+  zk-credits cline [cline arguments...]
+  zk-credits claude [claude arguments...]
   zk-credits setup codex [--model <model>]
   zk-credits codex [codex arguments...]
   zk-credits status
@@ -84,10 +88,10 @@ function printHelp() {
   zk-credits serve [--port <port>]
   eval "$(zk-credits env)"
 
-The Codex setup starts the loopback sidecar automatically; daily use is
-"zk-credits codex". serve/env remain available for other OpenAI-compatible
-clients. Set ZK_CREDITS_MNEMONIC only for a headless process; it is not
-persisted by that path.`);
+"zk-credits cline" and "zk-credits claude" configure and launch coding agents
+against the proof-aware loopback sidecar. The Codex companion remains available
+through setup codex.
+Set ZK_CREDITS_MNEMONIC only for a headless process; it is not persisted.`);
 }
 async function serve(args) {
     const port = readPort(args);
@@ -165,6 +169,18 @@ async function main() {
         isCodexProfileInstalled: () => isCodexProfileInstalled(codexHome),
         isSidecarHealthy: () => lifecycle.isHealthy(),
         launchCodex: (codexArgs) => launchCodexProcess(codexArgs),
+        launchCline: (clineArgs, localToken) => launchClineProcess({
+            args: clineArgs,
+            loopbackBaseUrl: loopbackBaseUrl(),
+            localToken,
+            stateDirectory: sidecarHome,
+        }),
+        launchClaude: (claudeArgs, localToken) => launchClaudeProcess({
+            args: claudeArgs,
+            loopbackBaseUrl: loopbackBaseUrl(),
+            localToken,
+            stateDirectory: sidecarHome,
+        }),
     });
     if (exitCode !== 0)
         process.exitCode = exitCode;

package/dist/cline-launcher.d.ts

@@ -0,0 +1,18 @@
+interface SpawnedProcess {
+    once(event: 'error', listener: (error: NodeJS.ErrnoException) => void): this;
+    once(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+}
+type ClineStdio = 'inherit' | ['ignore', 'ignore', 'inherit'];
+export type ClineSpawnCommand = (command: string, args: readonly string[], options: {
+    stdio: ClineStdio;
+    env: NodeJS.ProcessEnv;
+}) => SpawnedProcess;
+export interface LaunchClineOptions {
+    args: readonly string[];
+    loopbackBaseUrl: string;
+    localToken: string;
+    stateDirectory: string;
+}
+/** Configures and launches Cline against the proof-aware loopback transport. */
+export declare function launchClineProcess(options: LaunchClineOptions, spawnImpl?: ClineSpawnCommand): Promise<number>;
+export {};

package/dist/cline-launcher.js

@@ -0,0 +1,85 @@
+import { spawn } from 'node:child_process';
+import { chmod, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+const DEFAULT_CLINE_MODEL = 'openai/gpt-4o-mini';
+const spawnCommand = (command, args, options) => spawn(command, [...args], options);
+function openAiBaseUrl(loopbackBaseUrl) {
+    const url = new URL(loopbackBaseUrl);
+    if (url.protocol !== 'http:' || url.hostname !== '127.0.0.1') {
+        throw new Error('Cline companion must use a 127.0.0.1 HTTP sidecar URL');
+    }
+    return `${url.origin}/v1`;
+}
+function selectedModel(args) {
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        if (argument === '--model' || argument === '-m') {
+            const model = args[index + 1]?.trim();
+            if (!model)
+                throw new Error(`${argument} requires a model ID`);
+            return model;
+        }
+        if (argument?.startsWith('--model=')) {
+            const model = argument.slice('--model='.length).trim();
+            if (!model)
+                throw new Error('--model requires a model ID');
+            return model;
+        }
+    }
+    return DEFAULT_CLINE_MODEL;
+}
+function assertManagedProviderArguments(args) {
+    const managed = new Set(['--provider', '-P', '--key', '-k', '--config', '--data-dir']);
+    if (args.some((argument) => managed.has(argument) || argument.startsWith('--provider='))) {
+        throw new Error('zk-credits cline manages the provider, API key, and profile directory');
+    }
+}
+function waitForCline(child) {
+    return new Promise((resolve, reject) => {
+        child.once('error', (error) => {
+            if (error.code === 'ENOENT') {
+                reject(new Error('Cline CLI was not found; install it with npm install --global cline'));
+                return;
+            }
+            reject(error);
+        });
+        child.once('exit', (code) => resolve(code ?? 1));
+    });
+}
+/** Configures and launches Cline against the proof-aware loopback transport. */
+export async function launchClineProcess(options, spawnImpl = spawnCommand) {
+    assertManagedProviderArguments(options.args);
+    const baseUrl = openAiBaseUrl(options.loopbackBaseUrl);
+    const model = selectedModel(options.args);
+    const dataDirectory = join(options.stateDirectory, 'cline');
+    await mkdir(dataDirectory, { recursive: true, mode: 0o700 });
+    await chmod(dataDirectory, 0o700);
+    const environment = {
+        ...process.env,
+        OPENAI_BASE_URL: baseUrl,
+        OPENAI_API_KEY: options.localToken,
+    };
+    const authCode = await waitForCline(spawnImpl('cline', [
+        'auth',
+        '--provider', 'openai-compatible',
+        '--apikey', options.localToken,
+        '--modelid', model,
+        '--baseurl', baseUrl,
+        '--data-dir', dataDirectory,
+    ], {
+        stdio: ['ignore', 'ignore', 'inherit'],
+        env: environment,
+    }));
+    if (authCode !== 0) {
+        throw new Error(`Cline OpenAI-compatible provider setup failed with exit code ${authCode}`);
+    }
+    return waitForCline(spawnImpl('cline', [
+        '--provider', 'openai-compatible',
+        '--model', model,
+        '--data-dir', dataDirectory,
+        ...options.args,
+    ], {
+        stdio: 'inherit',
+        env: environment,
+    }));
+}

package/dist/codex-sdk-options.d.ts

@@ -0,0 +1,13 @@
+import type { CodexOptions, ThreadOptions } from '@openai/codex-sdk';
+export interface BuildCodexSdkOptionsInput {
+    loopbackBaseUrl: string;
+    token: string;
+    codexHome: string;
+    env?: Record<string, string>;
+}
+export interface BuildCodexThreadOptionsInput {
+    model?: string;
+    workingDirectory?: string;
+}
+export declare function buildCodexSdkOptions(input: BuildCodexSdkOptionsInput): CodexOptions;
+export declare function buildCodexThreadOptions(input?: BuildCodexThreadOptionsInput): ThreadOptions;

package/dist/codex-sdk-options.js

@@ -0,0 +1,33 @@
+import { DEFAULT_CODEX_MODEL } from './codex-profile.js';
+export function buildCodexSdkOptions(input) {
+    let url;
+    try {
+        url = new URL(input.loopbackBaseUrl);
+    }
+    catch {
+        throw new Error('Codex SDK provider must use a 127.0.0.1 HTTP sidecar URL with an explicit port');
+    }
+    if (url.protocol !== 'http:' || url.hostname !== '127.0.0.1' || !url.port) {
+        throw new Error('Codex SDK provider must use a 127.0.0.1 HTTP sidecar URL with an explicit port');
+    }
+    const baseUrl = `${url.origin}/v1`;
+    return {
+        baseUrl,
+        apiKey: input.token,
+        env: {
+            ...(input.env ?? process.env),
+            CODEX_HOME: input.codexHome,
+            OPENAI_BASE_URL: baseUrl,
+            OPENAI_API_KEY: input.token,
+        },
+    };
+}
+export function buildCodexThreadOptions(input) {
+    return {
+        model: input?.model ?? DEFAULT_CODEX_MODEL,
+        sandboxMode: 'read-only',
+        skipGitRepoCheck: true,
+        approvalPolicy: 'never',
+        ...(input?.workingDirectory ? { workingDirectory: input.workingDirectory } : {}),
+    };
+}