@losclaws/cli 0.1.1

package/src/config.js

@@ -0,0 +1,135 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { CliError } from './errors.js';
+import { sanitizeProfile } from './utils.js';
+
+const defaultConfig = {
+  version: 1,
+  currentProfile: 'default',
+  profiles: {
+    default: {
+      losclawsBaseUrl: 'https://losclaws.com',
+      clawarenaBaseUrl: 'https://arena.losclaws.com',
+      clawworkshopBaseUrl: 'https://workshop.losclaws.com',
+      accessToken: '',
+      apiKey: '',
+      subjectType: '',
+      agent: null,
+      human: null,
+      lastUpdatedAt: null,
+    },
+  },
+};
+
+export function getConfigPath(customPath) {
+  return customPath || path.join(os.homedir(), '.losclaws', 'config.json');
+}
+
+export async function loadConfig(customPath, selectedProfile) {
+  const configPath = getConfigPath(customPath);
+  const directory = path.dirname(configPath);
+  await fs.mkdir(directory, { recursive: true });
+
+  let config = structuredClone(defaultConfig);
+  try {
+    const raw = await fs.readFile(configPath, 'utf8');
+    config = mergeConfig(JSON.parse(raw));
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      if (error instanceof SyntaxError) {
+        throw new CliError(`Invalid config JSON at ${configPath}.`);
+      }
+      throw error;
+    }
+  }
+
+  const profileName = selectedProfile || process.env.LOSCLAWS_PROFILE || config.currentProfile || 'default';
+  if (!config.profiles[profileName]) {
+    config.profiles[profileName] = structuredClone(defaultConfig.profiles.default);
+  }
+
+  return {
+    configPath,
+    config,
+    profileName,
+    profile: config.profiles[profileName],
+  };
+}
+
+export async function saveProfile(state, patch) {
+  const nextProfile = {
+    ...state.profile,
+    ...patch,
+    lastUpdatedAt: new Date().toISOString(),
+  };
+
+  state.config.profiles[state.profileName] = nextProfile;
+  state.config.currentProfile = state.profileName;
+  state.profile = nextProfile;
+
+  await fs.writeFile(state.configPath, `${JSON.stringify(state.config, null, 2)}\n`, 'utf8');
+  return nextProfile;
+}
+
+export function clearedAuthProfile(profile) {
+  return {
+    ...profile,
+    accessToken: '',
+    apiKey: '',
+    subjectType: '',
+    agent: null,
+    human: null,
+  };
+}
+
+export function resolveRuntime(state, options) {
+  const env = process.env;
+  return {
+    losclawsBaseUrl:
+      options.losclawsUrl ||
+      env.LOSCLAWS_BASE_URL ||
+      state.profile.losclawsBaseUrl ||
+      defaultConfig.profiles.default.losclawsBaseUrl,
+    clawarenaBaseUrl:
+      options.arenaUrl ||
+      env.CLAWARENA_BASE_URL ||
+      state.profile.clawarenaBaseUrl ||
+      defaultConfig.profiles.default.clawarenaBaseUrl,
+    clawworkshopBaseUrl:
+      options.workshopUrl ||
+      env.CLAWWORKSHOP_BASE_URL ||
+      state.profile.clawworkshopBaseUrl ||
+      defaultConfig.profiles.default.clawworkshopBaseUrl,
+    accessToken:
+      options.token ||
+      env.LOSCLAWS_ACCESS_TOKEN ||
+      state.profile.accessToken ||
+      '',
+    apiKey:
+      options.apiKey ||
+      env.LOSCLAWS_API_KEY ||
+      state.profile.apiKey ||
+      '',
+  };
+}
+
+export function configForDisplay(state) {
+  return {
+    path: state.configPath,
+    profile: state.profileName,
+    data: sanitizeProfile(state.profile),
+  };
+}
+
+function mergeConfig(candidate) {
+  return {
+    ...structuredClone(defaultConfig),
+    ...candidate,
+    profiles: {
+      ...structuredClone(defaultConfig.profiles),
+      ...(candidate?.profiles || {}),
+    },
+  };
+}

package/src/errors.js

@@ -0,0 +1,9 @@
+export class CliError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = 'CliError';
+    this.code = options.code;
+    this.status = options.status;
+    this.details = options.details;
+  }
+}

package/src/http.js

@@ -0,0 +1,71 @@
+import { CliError } from './errors.js';
+import { joinUrl } from './utils.js';
+
+export async function requestJson({ method = 'GET', baseUrl, path, query, token, body, headers = {} }) {
+  const response = await fetch(joinUrl(baseUrl, path, query), {
+    method,
+    headers: buildHeaders({ token, hasBody: body !== undefined, headers }),
+    body: body !== undefined ? JSON.stringify(body) : undefined,
+  });
+
+  return handleJsonResponse(response);
+}
+
+export async function openEventStream({ baseUrl, path, query, token, headers = {} }) {
+  const response = await fetch(joinUrl(baseUrl, path, query), {
+    method: 'GET',
+    headers: buildHeaders({
+      token,
+      headers: {
+        Accept: 'text/event-stream',
+        ...headers,
+      },
+    }),
+  });
+
+  if (!response.ok) {
+    await handleJsonResponse(response);
+  }
+
+  if (!response.body) {
+    throw new CliError('The server did not return a readable event stream.');
+  }
+
+  return response;
+}
+
+function buildHeaders({ token, hasBody = false, headers = {} }) {
+  return {
+    ...(hasBody ? { 'Content-Type': 'application/json' } : {}),
+    ...(token ? { Authorization: `Bearer ${token}` } : {}),
+    ...headers,
+  };
+}
+
+async function handleJsonResponse(response) {
+  const text = await response.text();
+  const data = text ? safeParseJson(text) : null;
+
+  if (!response.ok) {
+    const message =
+      data?.error?.message ||
+      data?.message ||
+      data?.error ||
+      `Request failed with status ${response.status}`;
+    throw new CliError(message, {
+      status: response.status,
+      code: data?.error?.code || data?.code,
+      details: data,
+    });
+  }
+
+  return data;
+}
+
+function safeParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}

package/src/inspect.js

@@ -0,0 +1,252 @@
+import fs from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+const execTimeoutMs = 4_000;
+const execMaxBuffer = 256 * 1024;
+
+const inspectors = [
+  {
+    key: 'copilot',
+    name: 'GitHub Copilot CLI',
+    commands: ['copilot'],
+    modelCommands: [],
+  },
+  {
+    key: 'claude-code',
+    name: 'Claude Code',
+    commands: ['claude'],
+    modelCommands: [],
+  },
+  {
+    key: 'opencode',
+    name: 'OpenCode',
+    commands: ['opencode'],
+    modelCommands: [
+      ['models', '--json'],
+      ['models', 'list', '--json'],
+      ['models'],
+      ['models', 'list'],
+    ],
+  },
+];
+
+export async function inspectCodingAgents() {
+  const capabilities = [];
+  for (const inspector of inspectors) {
+    const capability = await inspectCodingAgent(inspector);
+    if (capability) {
+      capabilities.push(capability);
+    }
+  }
+  return capabilities;
+}
+
+async function inspectCodingAgent(inspector) {
+  const command = await findCommand(inspector.commands);
+  if (!command) {
+    return null;
+  }
+
+  const [version, helpResult, modelResult] = await Promise.all([
+    detectVersion(command),
+    runCommand(command, ['--help']),
+    discoverModels(command, inspector.modelCommands),
+  ]);
+
+  const supportsModelFlag = helpResult.ok && helpResult.stdout.includes('--model');
+  const notes = [...modelResult.notes];
+  let modelDiscovery = modelResult.modelDiscovery;
+
+  if (!modelDiscovery) {
+    if (modelResult.models.length > 0) {
+      modelDiscovery = 'explicit-list';
+    } else if (supportsModelFlag) {
+      modelDiscovery = 'manual-selection-only';
+      notes.push('The local CLI exposes --model, but it does not expose a local model-list command.');
+    } else {
+      modelDiscovery = 'undiscoverable';
+      notes.push('No supported local model discovery command was found for this CLI.');
+    }
+  }
+
+  return {
+    key: inspector.key,
+    name: inspector.name,
+    command: path.basename(command),
+    version,
+    models: modelResult.models,
+    modelDiscovery,
+    notes: normalizeStrings(notes),
+  };
+}
+
+async function discoverModels(command, probes) {
+  const notes = [];
+  for (const probe of probes) {
+    const result = await runCommand(command, probe);
+    if (!result.ok) {
+      continue;
+    }
+
+    const models = parseModelListOutput(result.stdout);
+    if (models.length > 0) {
+      return {
+        models,
+        modelDiscovery: 'explicit-list',
+        notes,
+      };
+    }
+
+    notes.push(`The command \`${path.basename(command)} ${probe.join(' ')}\` returned no parseable model list.`);
+  }
+
+  return { models: [], notes };
+}
+
+async function detectVersion(command) {
+  for (const args of [['--version'], ['version']]) {
+    const result = await runCommand(command, args);
+    if (!result.ok) {
+      continue;
+    }
+    const version = firstMeaningfulLine(result.stdout);
+    if (version) {
+      return version;
+    }
+  }
+  return '';
+}
+
+async function findCommand(candidates) {
+  const pathValue = process.env.PATH || '';
+  const directories = pathValue.split(path.delimiter).filter(Boolean);
+  const extensions = process.platform === 'win32'
+    ? (process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
+    : [''];
+
+  for (const candidate of candidates) {
+    const trimmed = String(candidate || '').trim();
+    if (!trimmed) {
+      continue;
+    }
+
+    for (const directory of directories) {
+      for (const extension of extensions) {
+        const filePath = path.join(directory, process.platform === 'win32' ? `${trimmed}${extension}` : trimmed);
+        try {
+          await fs.access(filePath, fsConstants.X_OK);
+          return filePath;
+        } catch {
+          // Keep scanning PATH candidates.
+        }
+      }
+    }
+  }
+
+  return '';
+}
+
+async function runCommand(command, args) {
+  try {
+    const { stdout, stderr } = await execFileAsync(command, args, {
+      timeout: execTimeoutMs,
+      maxBuffer: execMaxBuffer,
+      windowsHide: true,
+    });
+    return {
+      ok: true,
+      stdout: `${stdout || ''}${stderr ? `\n${stderr}` : ''}`.trim(),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      stdout: `${error.stdout || ''}${error.stderr ? `\n${error.stderr}` : ''}`.trim(),
+    };
+  }
+}
+
+export function parseModelListOutput(output) {
+  const text = String(output || '').trim();
+  if (!text) {
+    return [];
+  }
+
+  const json = tryParseJson(text);
+  if (json !== undefined) {
+    return normalizeStrings(extractModelNames(json));
+  }
+
+  return normalizeStrings(
+    text
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => looksLikeModelName(line)),
+  );
+}
+
+function extractModelNames(value) {
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => extractModelNames(entry));
+  }
+
+  if (typeof value === 'string') {
+    return [value];
+  }
+
+  if (!value || typeof value !== 'object') {
+    return [];
+  }
+
+  const modelKeys = ['models', 'data', 'items', 'availableModels'];
+  for (const key of modelKeys) {
+    if (key in value) {
+      return extractModelNames(value[key]);
+    }
+  }
+
+  for (const key of ['id', 'name', 'model']) {
+    if (typeof value[key] === 'string') {
+      return [value[key]];
+    }
+  }
+
+  return [];
+}
+
+function looksLikeModelName(line) {
+  if (!line) {
+    return false;
+  }
+  if (line.length > 80) {
+    return false;
+  }
+  if (/^usage:/i.test(line) || /^error:/i.test(line)) {
+    return false;
+  }
+  return /^[a-z0-9][a-z0-9._:-]*$/i.test(line);
+}
+
+function tryParseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return undefined;
+  }
+}
+
+function firstMeaningfulLine(value) {
+  return String(value || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .find(Boolean) || '';
+}
+
+function normalizeStrings(values) {
+  return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))].sort((left, right) =>
+    left.localeCompare(right),
+  );
+}

package/src/sse.js

@@ -0,0 +1,82 @@
+import { CliError } from './errors.js';
+
+export async function streamEvents(response, onEvent) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let event = createEvent();
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split(/\r?\n/);
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (line === '') {
+        if (event.data.length > 0) {
+          const result = await onEvent(normalizeEvent(event));
+          if (result === false) {
+            await reader.cancel();
+            return;
+          }
+        }
+        event = createEvent();
+        continue;
+      }
+
+      if (line.startsWith(':')) {
+        continue;
+      }
+
+      const separatorIndex = line.indexOf(':');
+      const field = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
+      const rawValue = separatorIndex === -1 ? '' : line.slice(separatorIndex + 1).replace(/^ /, '');
+
+      if (field === 'event') {
+        event.type = rawValue;
+      } else if (field === 'id') {
+        event.id = rawValue;
+      } else if (field === 'data') {
+        event.data.push(rawValue);
+      }
+    }
+  }
+}
+
+export function normalizeEvent(event) {
+  const rawData = event.data.join('\n');
+  let payload = rawData;
+
+  if (rawData) {
+    try {
+      payload = JSON.parse(rawData);
+    } catch {
+      payload = { raw: rawData };
+    }
+  }
+
+  return {
+    id: event.id,
+    type: event.type || 'message',
+    data: payload,
+  };
+}
+
+export function requireReadableStream(response) {
+  if (!response?.body?.getReader) {
+    throw new CliError('Readable stream support is required for SSE commands.');
+  }
+}
+
+function createEvent() {
+  return {
+    id: '',
+    type: '',
+    data: [],
+  };
+}