@ekkos/cli 1.3.1 → 1.3.5

package/dist/capture/jsonl-rewriter.d.ts

@@ -87,7 +87,7 @@ export declare function getEvictionStats(): {
     lastEviction?: string;
 };
 /**
- * Get evicted content for retrieval (used by ccDNA)
+ * Get evicted content for retrieval
  */
 export declare function getEvictedContent(limit?: number): Array<{
     timestamp: string;

package/dist/capture/jsonl-rewriter.js

@@ -283,7 +283,7 @@ function truncateToolResult(line) {
         return line;
     }
 }
-// Evicted content store (for retrieval by ccDNA)
+// Evicted content store
 const EVICTED_STORE = path.join(os.homedir(), '.ekkos', 'evicted-context.jsonl');
 const EKKOS_CAPTURE_ENDPOINT = 'https://mcp.ekkos.dev/api/v1/context/evict';
 const EKKOS_API_URL = process.env.EKKOS_API_URL || 'https://mcp.ekkos.dev';
@@ -716,7 +716,7 @@ function evictToTarget(filePath, currentPercent, sessionId, sessionName) {
         debugLog('EVICTION_NOOP', 'No lines to evict or truncate');
         return { success: true, evicted: 0, truncated: 0, newPercent: currentPercent };
     }
-    // Save evicted content for ccDNA retrieval
+    // Save evicted content
     const evictedLines = lines.filter(l => toRemove.has(l.index)).map(l => l.raw);
     const evictedIndices = lines.filter(l => toRemove.has(l.index)).map(l => l.index);
     // ═══════════════════════════════════════════════════════════════════════════
@@ -1346,7 +1346,7 @@ function getEvictionStats() {
     }
 }
 /**
- * Get evicted content for retrieval (used by ccDNA)
+ * Get evicted content for retrieval
  */
 function getEvictedContent(limit = 10) {
     try {

package/dist/capture/transcript-repair.d.ts

@@ -1,13 +1,13 @@
 /**
  * Transcript Repair - Handles orphan tool_result recovery
  *
- * When ccDNA's validate mode detects orphan tool_results (tool_result without
+ * When orphan tool_results are detected (tool_result without
  * matching tool_use), this module repairs the transcript:
  *
  * 1. ROLLBACK (preferred): Restore from backup if valid
  * 2. SURGICAL REPAIR (fallback): Remove orphan tool_result lines
  *
- * This closes the loop: ccDNA detects → ekkos-cli repairs → /clear + /continue
+ * This closes the loop: orphan detected → ekkos-cli repairs → transcript clean
  */
 type RepairAction = 'none' | 'rollback' | 'surgical_repair' | 'failed';
 export interface RepairResult {

package/dist/capture/transcript-repair.js

@@ -2,13 +2,13 @@
 /**
  * Transcript Repair - Handles orphan tool_result recovery
  *
- * When ccDNA's validate mode detects orphan tool_results (tool_result without
+ * When orphan tool_results are detected (tool_result without
  * matching tool_use), this module repairs the transcript:
  *
  * 1. ROLLBACK (preferred): Restore from backup if valid
  * 2. SURGICAL REPAIR (fallback): Remove orphan tool_result lines
  *
- * This closes the loop: ccDNA detects → ekkos-cli repairs → /clear + /continue
+ * This closes the loop: orphan detected → ekkos-cli repairs → transcript clean
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;

package/dist/commands/claw.d.ts

@@ -0,0 +1,13 @@
+interface ClawStatusOptions {
+    json?: boolean;
+    proxyUrl?: string;
+    model?: string;
+    workspace?: string;
+}
+interface ClawUpgradeOptions extends ClawStatusOptions {
+    apply?: boolean;
+    force?: boolean;
+}
+export declare function clawStatus(options?: ClawStatusOptions): Promise<void>;
+export declare function clawUpgrade(options?: ClawUpgradeOptions): Promise<void>;
+export {};

package/dist/commands/claw.js

@@ -0,0 +1,253 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clawStatus = clawStatus;
+exports.clawUpgrade = clawUpgrade;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const net_1 = __importDefault(require("net"));
+const OPENCLAW_CONFIG_PATH = (0, path_1.join)((0, os_1.homedir)(), '.openclaw', 'openclaw.json');
+const DEFAULT_PROXY_URL = process.env.EKKOS_CLAW_PROXY_URL || 'https://proxy.ekkos.dev';
+const DEFAULT_MODEL = process.env.EKKOS_CLAW_MODEL || 'ekkos-proxy/claude-sonnet-4-6';
+const DEFAULT_WORKSPACE_PATH = process.env.EKKOS_CLAW_WORKSPACE || '/Volumes/Dev_Disk/openclaw/workspace';
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function readConfig() {
+    if (!(0, fs_1.existsSync)(OPENCLAW_CONFIG_PATH))
+        return null;
+    try {
+        const raw = (0, fs_1.readFileSync)(OPENCLAW_CONFIG_PATH, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function ensureObject(parent, key) {
+    const current = parent[key];
+    if (isRecord(current))
+        return current;
+    const next = {};
+    parent[key] = next;
+    return next;
+}
+function timestampForBackup() {
+    return new Date().toISOString().replace(/[:.]/g, '-');
+}
+async function isPortListening(port, host = '127.0.0.1', timeoutMs = 1000) {
+    return new Promise((resolve) => {
+        const socket = new net_1.default.Socket();
+        let done = false;
+        const finish = (value) => {
+            if (done)
+                return;
+            done = true;
+            socket.destroy();
+            resolve(value);
+        };
+        socket.setTimeout(timeoutMs);
+        socket.once('connect', () => finish(true));
+        socket.once('timeout', () => finish(false));
+        socket.once('error', () => finish(false));
+        socket.connect(port, host);
+    });
+}
+async function isHttpReachable(url, timeoutMs = 1400) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            signal: controller.signal,
+        });
+        return response.ok || response.status < 500;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function collectStatus(options = {}) {
+    const expectedProxy = options.proxyUrl || DEFAULT_PROXY_URL;
+    const expectedModel = options.model || DEFAULT_MODEL;
+    const workspacePath = options.workspace || DEFAULT_WORKSPACE_PATH;
+    const config = readConfig();
+    const configFound = config !== null;
+    const configValid = configFound && isRecord(config);
+    const gatewayPort = Number(config?.gateway?.port || 18789);
+    const listenerActive = await isPortListening(gatewayPort);
+    const uiReachable = await isHttpReachable(`http://127.0.0.1:${gatewayPort}/`);
+    const workspaceExists = (0, fs_1.existsSync)(workspacePath);
+    let primaryModel = null;
+    let ekkosProxyBaseUrl = null;
+    let ekkosProxyApi = null;
+    if (configValid && config) {
+        const agents = config.agents;
+        const defaults = isRecord(agents?.defaults) ? agents?.defaults : undefined;
+        const model = isRecord(defaults?.model) ? defaults?.model : undefined;
+        if (typeof model?.primary === 'string')
+            primaryModel = model.primary;
+        const models = isRecord(config.models) ? config.models : undefined;
+        const providers = isRecord(models?.providers) ? models?.providers : undefined;
+        const ekkosProxy = isRecord(providers?.['ekkos-proxy']) ? providers?.['ekkos-proxy'] : undefined;
+        if (typeof ekkosProxy?.baseUrl === 'string')
+            ekkosProxyBaseUrl = ekkosProxy.baseUrl;
+        if (typeof ekkosProxy?.api === 'string')
+            ekkosProxyApi = ekkosProxy.api;
+    }
+    const warnings = [];
+    if (!configFound)
+        warnings.push(`Missing OpenClaw config: ${OPENCLAW_CONFIG_PATH}`);
+    if (configFound && !configValid)
+        warnings.push(`Invalid JSON in: ${OPENCLAW_CONFIG_PATH}`);
+    if (!listenerActive)
+        warnings.push(`No listener on 127.0.0.1:${gatewayPort}`);
+    if (!uiReachable)
+        warnings.push(`OpenClaw UI check failed: http://127.0.0.1:${gatewayPort}/`);
+    if (!workspaceExists)
+        warnings.push(`Workspace not found: ${workspacePath}`);
+    if (primaryModel !== expectedModel)
+        warnings.push(`Primary model is '${primaryModel ?? 'unset'}' (expected '${expectedModel}')`);
+    if (ekkosProxyBaseUrl !== expectedProxy)
+        warnings.push(`ekkos-proxy baseUrl is '${ekkosProxyBaseUrl ?? 'unset'}' (expected '${expectedProxy}')`);
+    if (ekkosProxyApi !== 'anthropic-messages')
+        warnings.push(`ekkos-proxy api is '${ekkosProxyApi ?? 'unset'}' (expected 'anthropic-messages')`);
+    return {
+        timestamp: new Date().toISOString(),
+        configPath: OPENCLAW_CONFIG_PATH,
+        configFound,
+        configValid,
+        gatewayPort,
+        listenerActive,
+        uiReachable,
+        primaryModel,
+        ekkosProxyBaseUrl,
+        ekkosProxyApi,
+        workspacePath,
+        workspaceExists,
+        warnings,
+    };
+}
+function printStatus(report) {
+    const ok = (value) => (value ? chalk_1.default.green('yes') : chalk_1.default.red('no'));
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('ekkOS_Claw Status'));
+    console.log(chalk_1.default.gray(`  checked: ${report.timestamp}`));
+    console.log('');
+    console.log(`  OpenClaw config:    ${ok(report.configFound && report.configValid)} ${chalk_1.default.gray(report.configPath)}`);
+    console.log(`  Listener active:    ${ok(report.listenerActive)} ${chalk_1.default.gray(`127.0.0.1:${report.gatewayPort}`)}`);
+    console.log(`  UI reachable:       ${ok(report.uiReachable)} ${chalk_1.default.gray(`http://127.0.0.1:${report.gatewayPort}/`)}`);
+    console.log(`  Workspace exists:   ${ok(report.workspaceExists)} ${chalk_1.default.gray(report.workspacePath)}`);
+    console.log(`  Primary model:      ${chalk_1.default.white(report.primaryModel || 'unset')}`);
+    console.log(`  ekkos-proxy URL:    ${chalk_1.default.white(report.ekkosProxyBaseUrl || 'unset')}`);
+    console.log(`  ekkos-proxy API:    ${chalk_1.default.white(report.ekkosProxyApi || 'unset')}`);
+    console.log('');
+    if (report.warnings.length > 0) {
+        console.log(chalk_1.default.yellow('Warnings:'));
+        for (const warning of report.warnings) {
+            console.log(chalk_1.default.yellow(`  - ${warning}`));
+        }
+        console.log('');
+    }
+    else {
+        console.log(chalk_1.default.green('Integration looks healthy.'));
+        console.log('');
+    }
+}
+function planUpgrade(config, options) {
+    const nextConfig = JSON.parse(JSON.stringify(config));
+    const changes = [];
+    const proxyUrl = options.proxyUrl || DEFAULT_PROXY_URL;
+    const modelName = options.model || DEFAULT_MODEL;
+    const models = ensureObject(nextConfig, 'models');
+    const providers = ensureObject(models, 'providers');
+    const existingProvider = isRecord(providers['ekkos-proxy']) ? providers['ekkos-proxy'] : {};
+    const nextProvider = { ...existingProvider };
+    if (nextProvider.baseUrl !== proxyUrl) {
+        changes.push(`models.providers.ekkos-proxy.baseUrl -> ${proxyUrl}`);
+        nextProvider.baseUrl = proxyUrl;
+    }
+    if (nextProvider.api !== 'anthropic-messages') {
+        changes.push(`models.providers.ekkos-proxy.api -> anthropic-messages`);
+        nextProvider.api = 'anthropic-messages';
+    }
+    const desiredProviderModels = ['claude-sonnet-4-6', 'claude-opus-4-6'];
+    const providerModels = Array.isArray(nextProvider.models)
+        ? nextProvider.models.filter((v) => typeof v === 'string')
+        : [];
+    const mergedProviderModels = Array.from(new Set([...providerModels, ...desiredProviderModels]));
+    if (mergedProviderModels.length !== providerModels.length) {
+        changes.push(`models.providers.ekkos-proxy.models += ${desiredProviderModels.join(', ')}`);
+    }
+    nextProvider.models = mergedProviderModels;
+    providers['ekkos-proxy'] = nextProvider;
+    const agents = ensureObject(nextConfig, 'agents');
+    const defaults = ensureObject(agents, 'defaults');
+    const model = ensureObject(defaults, 'model');
+    if (model.primary !== modelName) {
+        changes.push(`agents.defaults.model.primary -> ${modelName}`);
+        model.primary = modelName;
+    }
+    return { nextConfig, changes };
+}
+async function clawStatus(options = {}) {
+    const report = await collectStatus(options);
+    if (options.json) {
+        console.log(JSON.stringify(report, null, 2));
+        return;
+    }
+    printStatus(report);
+}
+async function clawUpgrade(options = {}) {
+    const config = readConfig();
+    if (!config) {
+        console.error(chalk_1.default.red(`OpenClaw config missing or invalid: ${OPENCLAW_CONFIG_PATH}`));
+        process.exit(1);
+    }
+    const { nextConfig, changes } = planUpgrade(config, options);
+    const reportBefore = await collectStatus(options);
+    if (options.json) {
+        console.log(JSON.stringify({
+            apply: !!options.apply,
+            force: !!options.force,
+            changes,
+            before: reportBefore,
+        }, null, 2));
+        return;
+    }
+    console.log('');
+    console.log(chalk_1.default.cyan.bold('ekkOS_Claw Upgrade (foundation)'));
+    console.log('');
+    if (changes.length === 0) {
+        console.log(chalk_1.default.green('No config changes needed. OpenClaw already points to ekkOS proxy.'));
+        console.log('');
+        printStatus(reportBefore);
+        return;
+    }
+    console.log(chalk_1.default.cyan('Planned changes:'));
+    for (const change of changes) {
+        console.log(`  - ${change}`);
+    }
+    console.log('');
+    if (!options.apply) {
+        console.log(chalk_1.default.yellow('Dry run only. Re-run with --apply to write config changes.'));
+        console.log('');
+        return;
+    }
+    const backupPath = `${OPENCLAW_CONFIG_PATH}.bak.${timestampForBackup()}`;
+    (0, fs_1.copyFileSync)(OPENCLAW_CONFIG_PATH, backupPath);
+    (0, fs_1.writeFileSync)(OPENCLAW_CONFIG_PATH, `${JSON.stringify(nextConfig, null, 2)}\n`, 'utf-8');
+    console.log(chalk_1.default.green(`Updated ${OPENCLAW_CONFIG_PATH}`));
+    console.log(chalk_1.default.gray(`Backup written: ${backupPath}`));
+    console.log('');
+    const reportAfter = await collectStatus(options);
+    printStatus(reportAfter);
+}