zk-credits 0.1.0 → 0.1.1

package/dist/cli-runtime.d.ts

@@ -10,6 +10,7 @@ export interface CliCommandDependencies {
     isCodexProfileInstalled(): Promise<boolean>;
     isSidecarHealthy(): Promise<boolean>;
     launchCodex(args: readonly string[]): Promise<number>;
+    launchCline(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,15 @@ 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);
+        }
         default:
-            throw new Error('Usage: zk-credits <setup codex|codex|status|token|import-mnemonic|serve|env>');
+            throw new Error('Usage: zk-credits <cline|setup codex|codex|status|token|import-mnemonic|serve|env>');
     }
 }

package/dist/cli.js

@@ -2,6 +2,7 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { launchCodexProcess } from './codex-launcher.js';
+import { launchClineProcess } from './cline-launcher.js';
 import { isCodexProfileInstalled, resolveCodexHome, writeCodexProfile, } from './codex-profile.js';
 import { IdentityStore } from './identity.js';
 import { createLocalProofGenerator } from './local-prover.js';
@@ -77,6 +78,7 @@ async function readHiddenMnemonic() {
 }
 function printHelp() {
     console.log(`Usage:
+  zk-credits cline [cline arguments...]
   zk-credits setup codex [--model <model>]
   zk-credits codex [codex arguments...]
   zk-credits status
@@ -84,10 +86,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" is the zero-configuration coding-agent path: it starts the
+sidecar, configures an isolated OpenAI-compatible Cline profile, and forwards
+all Cline arguments. 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 +167,12 @@ async function main() {
         isCodexProfileInstalled: () => isCodexProfileInstalled(codexHome),
         isSidecarHealthy: () => lifecycle.isHealthy(),
         launchCodex: (codexArgs) => launchCodexProcess(codexArgs),
+        launchCline: (clineArgs, localToken) => launchClineProcess({
+            args: clineArgs,
+            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/sidecar.js

@@ -104,7 +104,7 @@ export function createSidecarServer(options) {
                 body: body.raw,
             });
             await relayGatewayResponse(res, upstream);
-            if (upstream.status >= 200 && upstream.status < 300) {
+            if (upstream.status >= 200 && upstream.status < 300 && upstream.status !== 202) {
                 await options.ledger.consume(reservation.requestDigest);
             }
         }

package/dist/zk-credits.js

@@ -3,7 +3,7 @@ import { createRequire as __createNodeRequire } from 'node:module'; const requir
 
 // dist/cli.js
 import { homedir } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 
 // dist/codex-launcher.js
 import { spawn } from "node:child_process";
@@ -127,6 +127,100 @@ async function launchCodexProcess(args, spawnImpl = spawnCommand) {
   });
 }
 
+// dist/cline-launcher.js
+import { spawn as spawn2 } from "node:child_process";
+import { chmod as chmod2, mkdir as mkdir2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var DEFAULT_CLINE_MODEL = "openai/gpt-4o-mini";
+var spawnCommand2 = (command, args, options) => spawn2(command, [...args], options);
+function openAiBaseUrl(loopbackBaseUrl2) {
+  const url = new URL(loopbackBaseUrl2);
+  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 = /* @__PURE__ */ 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((resolve2, 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) => resolve2(code ?? 1));
+  });
+}
+async function launchClineProcess(options, spawnImpl = spawnCommand2) {
+  assertManagedProviderArguments(options.args);
+  const baseUrl = openAiBaseUrl(options.loopbackBaseUrl);
+  const model = selectedModel(options.args);
+  const dataDirectory = join2(options.stateDirectory, "cline");
+  await mkdir2(dataDirectory, { recursive: true, mode: 448 });
+  await chmod2(dataDirectory, 448);
+  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
+  }));
+}
+
 // dist/identity.js
 import * as keytar from "keytar";
 
@@ -398,7 +492,7 @@ import { resolve } from "node:path";
 // dist/artifact-manifest.js
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 var CIRCUIT_MANIFEST = [
   {
     file: "rln_nullifier.wasm",
@@ -415,7 +509,7 @@ var CIRCUIT_MANIFEST = [
 ];
 async function verifyArtifactManifest(artifactDirectory, manifest = CIRCUIT_MANIFEST) {
   for (const artifact of manifest) {
-    const content = await readFile(join2(artifactDirectory, artifact.file));
+    const content = await readFile(join3(artifactDirectory, artifact.file));
     const digest = createHash("sha256").update(content).digest("hex");
     if (digest !== artifact.sha256) {
       throw new Error(`Circuit artifact hash mismatch: ${artifact.file}`);
@@ -509,15 +603,15 @@ var MembershipClient = class {
 
 // dist/sidecar-config.js
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 function createLoopbackToken() {
   return randomBytes2(32).toString("base64url");
 }
 function sidecarStatePaths(stateDirectory2) {
   return {
-    ledgerPath: join3(stateDirectory2, "tickets.json"),
-    tokenPath: join3(stateDirectory2, "loopback-token"),
-    logPath: join3(stateDirectory2, "sidecar.log")
+    ledgerPath: join4(stateDirectory2, "tickets.json"),
+    tokenPath: join4(stateDirectory2, "loopback-token"),
+    logPath: join4(stateDirectory2, "sidecar.log")
   };
 }
 function formatOpenAiEnvironment(loopbackBaseUrl2, localToken) {
@@ -581,29 +675,37 @@ 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);
+    }
     default:
-      throw new Error("Usage: zk-credits <setup codex|codex|status|token|import-mnemonic|serve|env>");
+      throw new Error("Usage: zk-credits <cline|setup codex|codex|status|token|import-mnemonic|serve|env>");
   }
 }
 
 // dist/node-sidecar-lifecycle.js
-import { spawn as spawn2 } from "node:child_process";
-import { chmod as chmod3, mkdir as mkdir3, open } from "node:fs/promises";
+import { spawn as spawn3 } from "node:child_process";
+import { chmod as chmod4, mkdir as mkdir4, open } from "node:fs/promises";
 import { dirname as dirname2 } from "node:path";
 
 // dist/sidecar-state.js
-import { chmod as chmod2, mkdir as mkdir2, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { chmod as chmod3, mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname } from "node:path";
 async function writeLoopbackToken(tokenPath, token) {
   if (!token)
     throw new Error("Loopback token is required");
-  await mkdir2(dirname(tokenPath), { recursive: true, mode: 448 });
+  await mkdir3(dirname(tokenPath), { recursive: true, mode: 448 });
   const temporaryPath = `${tokenPath}.tmp`;
   await writeFile2(temporaryPath, `${token}
 `, { encoding: "utf8", mode: 384 });
-  await chmod2(temporaryPath, 384);
+  await chmod3(temporaryPath, 384);
   await rename2(temporaryPath, tokenPath);
-  await chmod2(tokenPath, 384);
+  await chmod3(tokenPath, 384);
 }
 async function readLoopbackToken(tokenPath) {
   const token = (await readFile3(tokenPath, "utf8")).trim();
@@ -614,11 +716,11 @@ async function readLoopbackToken(tokenPath) {
 
 // dist/node-sidecar-lifecycle.js
 async function startDetachedProcess(specification) {
-  await mkdir3(dirname2(specification.logPath), { recursive: true, mode: 448 });
+  await mkdir4(dirname2(specification.logPath), { recursive: true, mode: 448 });
   const log = await open(specification.logPath, "a", 384);
-  await chmod3(specification.logPath, 384);
+  await chmod4(specification.logPath, 384);
   try {
-    const child = spawn2(specification.executable, specification.args, {
+    const child = spawn3(specification.executable, specification.args, {
       detached: true,
       env: specification.env,
       stdio: ["ignore", log.fd, log.fd]
@@ -794,7 +896,7 @@ function createSidecarServer(options) {
         body: body.raw
       });
       await relayGatewayResponse(res, upstream);
-      if (upstream.status >= 200 && upstream.status < 300) {
+      if (upstream.status >= 200 && upstream.status < 300 && upstream.status !== 202) {
         await options.ledger.consume(reservation.requestDigest);
       }
     } catch (error) {
@@ -841,7 +943,7 @@ function createSidecarServer(options) {
 }
 
 // dist/ticket-ledger.js
-import { mkdir as mkdir4, readFile as readFile4, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile4, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname3 } from "node:path";
 function parseLedger(raw) {
   const parsed = JSON.parse(raw);
@@ -914,7 +1016,7 @@ var TicketLedger = class {
     }
   }
   async write(ledger) {
-    await mkdir4(dirname3(this.filePath), { recursive: true, mode: 448 });
+    await mkdir5(dirname3(this.filePath), { recursive: true, mode: 448 });
     const temporaryPath = `${this.filePath}.tmp`;
     await writeFile3(temporaryPath, JSON.stringify(ledger), { encoding: "utf8", mode: 384 });
     await rename3(temporaryPath, this.filePath);
@@ -925,7 +1027,7 @@ var TicketLedger = class {
 var DEFAULT_GATEWAY_URL = "https://zk-credits-gateway.onrender.com";
 var DEFAULT_PORT = 3210;
 function stateDirectory() {
-  return process.env.ZK_CREDITS_HOME || join4(homedir(), ".zk-credits");
+  return process.env.ZK_CREDITS_HOME || join5(homedir(), ".zk-credits");
 }
 function loopbackBaseUrl() {
   const port = Number(process.env.ZK_CREDITS_SIDECAR_PORT || DEFAULT_PORT);
@@ -984,6 +1086,7 @@ async function readHiddenMnemonic() {
 }
 function printHelp() {
   console.log(`Usage:
+  zk-credits cline [cline arguments...]
   zk-credits setup codex [--model <model>]
   zk-credits codex [codex arguments...]
   zk-credits status
@@ -991,10 +1094,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" is the zero-configuration coding-agent path: it starts the
+sidecar, configures an isolated OpenAI-compatible Cline profile, and forwards
+all Cline arguments. 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);
@@ -1076,7 +1179,13 @@ async function main() {
     ensureSidecar: () => ensureSidecarReady(lifecycle),
     isCodexProfileInstalled: () => isCodexProfileInstalled(codexHome),
     isSidecarHealthy: () => lifecycle.isHealthy(),
-    launchCodex: (codexArgs) => launchCodexProcess(codexArgs)
+    launchCodex: (codexArgs) => launchCodexProcess(codexArgs),
+    launchCline: (clineArgs, localToken) => launchClineProcess({
+      args: clineArgs,
+      loopbackBaseUrl: loopbackBaseUrl(),
+      localToken,
+      stateDirectory: sidecarHome
+    })
   });
   if (exitCode !== 0)
     process.exitCode = exitCode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zk-credits",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Loopback proof-aware OpenAI transport for ZK Credits.",
   "type": "module",
   "engines": {