@matterailab/orbcode 0.1.3

package/dist/api/models.js

@@ -0,0 +1,49 @@
+export const AXON_MODELS = {
+    "axon-code-2-5-mini": {
+        id: "axon-code-2-5-mini",
+        name: "Axon Code 2.5 Mini (free)",
+        description: "Axon Mini is an general purpose super intelligent LLM coding model for low-effort day-to-day tasks",
+        contextWindow: 400000,
+        maxOutputTokens: 64000,
+        supportsImages: true,
+        inputPrice: 0.0000005,
+        outputPrice: 0.0000015,
+        free: true,
+    },
+    "axon-code-2-5-pro": {
+        id: "axon-code-2-5-pro",
+        name: "Axon Code 2.5 Pro",
+        description: "Axon Code 2.5 Pro is the next-generation of Axon Code for coding tasks, currently in experimental stage.",
+        contextWindow: 400000,
+        maxOutputTokens: 64000,
+        supportsImages: true,
+        inputPrice: 0.000002,
+        outputPrice: 0.000006,
+        free: false,
+    },
+};
+export const DEFAULT_MODEL_ID = "axon-code-2-5-pro";
+/** Add user-defined models (from settings.json) to the registry. */
+export function registerCustomModels(models) {
+    for (const model of models) {
+        if (!model || typeof model.id !== "string" || !model.id)
+            continue;
+        AXON_MODELS[model.id] = {
+            id: model.id,
+            name: model.name ?? model.id,
+            description: model.description ?? "Custom model from settings.json",
+            contextWindow: model.contextWindow ?? 200_000,
+            maxOutputTokens: model.maxOutputTokens ?? 32_000,
+            supportsImages: model.supportsImages ?? false,
+            inputPrice: model.inputPrice ?? 0,
+            outputPrice: model.outputPrice ?? 0,
+            free: (model.inputPrice ?? 0) === 0 && (model.outputPrice ?? 0) === 0,
+        };
+    }
+}
+export function isValidAxonModel(modelId) {
+    return modelId in AXON_MODELS;
+}
+export function getModel(modelId) {
+    return AXON_MODELS[modelId] ?? AXON_MODELS[DEFAULT_MODEL_ID];
+}

package/dist/api/stream.js

@@ -0,0 +1 @@
+export {};

package/dist/auth/auth.js

@@ -0,0 +1,172 @@
+// Auth ported from the Orbital extension: a MatterAI JWT acts as the API key.
+// Backend URL resolution mirrors getKiloBaseUriFromToken / getKiloUrlFromToken.
+export const DEFAULT_BACKEND_URL = "https://api.matterai.so";
+export const API_GATEWAY_PATH = "https://api2.matterai.so/v1/web/";
+export function getBaseUrlFromToken(token) {
+    if (token) {
+        try {
+            const payloadString = token.split(".")[1];
+            if (payloadString) {
+                const payload = JSON.parse(Buffer.from(payloadString, "base64").toString());
+                // UNTRUSTED payload: only used to detect the development environment,
+                // never to read URLs directly.
+                if (payload.env === "development")
+                    return "http://localhost:3000";
+            }
+        }
+        catch {
+            // fall through to production URL
+        }
+    }
+    return DEFAULT_BACKEND_URL;
+}
+/** Re-host targetUrl onto the backend resolved from the token. */
+export function getUrlFromToken(targetUrl, token) {
+    const target = new URL(targetUrl);
+    const { protocol, host } = new URL(getBaseUrlFromToken(token));
+    Object.assign(target, { protocol, host });
+    return target.toString();
+}
+export const APP_URL = "https://app.matterai.so";
+export function getSignInUrl() {
+    return `${APP_URL}/authentication/sign-in?loginType=extension&source=cli`;
+}
+function deviceAuthBaseUrl() {
+    return process.env.ORBCODE_BACKEND_URL || DEFAULT_BACKEND_URL;
+}
+function deviceAuthAppUrl() {
+    return process.env.ORBCODE_APP_URL || APP_URL;
+}
+export async function startDeviceAuth() {
+    const response = await fetch(`${deviceAuthBaseUrl()}/orbcode/auth/start`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: "{}",
+    });
+    if (!response.ok) {
+        throw new Error(`Could not start sign-in (${response.status}). Try again or paste a token manually.`);
+    }
+    const data = (await response.json());
+    if (!data.devicecode) {
+        throw new Error("Sign-in service returned no device code.");
+    }
+    return {
+        devicecode: data.devicecode,
+        expiresIn: data.expiresIn ?? 600,
+        interval: data.interval ?? 3,
+    };
+}
+export function getAuthorizeUrl(devicecode) {
+    return `${deviceAuthAppUrl()}/orbital?loginType=orbcode&devicecode=${encodeURIComponent(devicecode)}`;
+}
+export async function pollDeviceAuth(devicecode) {
+    const response = await fetch(`${deviceAuthBaseUrl()}/orbcode/auth/poll?devicecode=${encodeURIComponent(devicecode)}`);
+    if (!response.ok) {
+        // Transient server/network errors are treated as pending; the caller's
+        // overall deadline still bounds the wait.
+        return { status: "pending" };
+    }
+    const data = (await response.json());
+    if (data.status === "authorized" && data.token) {
+        return { status: "authorized", token: data.token };
+    }
+    if (data.status === "expired") {
+        return { status: "expired" };
+    }
+    return { status: "pending" };
+}
+export async function fetchProfile(token) {
+    const url = getUrlFromToken("https://api.matterai.so/axoncode/profile", token);
+    const response = await fetch(url, {
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    });
+    if (!response.ok) {
+        throw new Error(`Profile request failed (${response.status}). Your token may be invalid or expired.`);
+    }
+    return (await response.json());
+}
+/**
+ * Extract a clean title from potentially malformed input: a plain string,
+ * a JSON object string ('{"title":"…"}'), or an object with a title field.
+ * Ported from the extension's taskMetadata sanitizeTitle.
+ */
+function sanitizeTitle(raw) {
+    if (raw == null)
+        return undefined;
+    if (typeof raw === "string") {
+        const trimmed = raw.trim();
+        if (!trimmed)
+            return undefined;
+        if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+            try {
+                const extracted = sanitizeTitle(JSON.parse(trimmed));
+                if (extracted)
+                    return extracted;
+            }
+            catch {
+                // not JSON, use as plain string
+            }
+        }
+        return trimmed;
+    }
+    if (typeof raw === "object") {
+        const maybe = raw["title"];
+        if (maybe != null)
+            return sanitizeTitle(maybe);
+    }
+    return undefined;
+}
+/**
+ * Fetch the backend-generated task title (GET /axoncode/meta/<taskId>).
+ * The title only exists after the first response starts streaming, so this
+ * retries a few times. Ported from the extension's fetchTaskTitle.
+ */
+export async function fetchTaskTitle(taskId, token, maxRetries = 3, retryDelayMs = 2000) {
+    if (!token)
+        return null;
+    const url = getUrlFromToken(`https://api.matterai.so/axoncode/meta/${taskId}`, token);
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            const response = await fetch(url, {
+                headers: { Authorization: `Bearer ${token}` },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (response.ok) {
+                const data = await response.json().catch(() => undefined);
+                const title = sanitizeTitle(data);
+                if (title)
+                    return title;
+            }
+        }
+        catch {
+            // network/timeout: fall through to retry
+        }
+        if (attempt < maxRetries) {
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+        }
+    }
+    return null;
+}
+export async function fetchBalance(token, organizationId) {
+    try {
+        const url = getUrlFromToken("https://api.matterai.so/api/profile/balance", token);
+        const headers = { Authorization: `Bearer ${token}` };
+        if (organizationId)
+            headers["X-KiloCode-OrganizationId"] = organizationId;
+        const response = await fetch(url, { headers });
+        if (!response.ok)
+            return undefined;
+        const data = (await response.json());
+        return data.balance;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Validate a pasted token: well-formed JWT + accepted by the profile endpoint. */
+export async function verifyToken(token) {
+    if (token.split(".").length !== 3) {
+        throw new Error("That doesn't look like a valid token (expected a JWT).");
+    }
+    return fetchProfile(token);
+}

package/dist/branding.js

@@ -0,0 +1,31 @@
+import * as fs from "node:fs";
+export const PRODUCT_NAME = "OrbCode CLI";
+export const BIN_NAME = "orbcode";
+export const VERSION = (() => {
+    try {
+        // dist/branding.js -> ../package.json
+        const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        return pkg.version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+})();
+export const TAGLINE = "powered by Axon models by MatterAI";
+export const COLORS = {
+    primary: "#c4fdff",
+    accent: "#4EC9B0",
+    dim: "gray",
+    error: "#e86464",
+    warning: "#e2ce76",
+    success: "#43df94",
+    thinking: "#8cd3de",
+    user: "#569CD6",
+};
+export const LOGO = `
+  ___         _       ____             _
+ / _ \\  _ __ | |__   / ___|  ___    __| |  ___
+| | | || '__|| '_ \\ | |     / _ \\  / _\` | / _ \\
+| |_| || |   | |_) || |___ | (_) || (_| ||  __/
+ \\___/ |_|   |_.__/  \\____| \\___/  \\__,_| \\___|
+`;

package/dist/config/promptHistory.js

@@ -0,0 +1,33 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getConfigDir } from "./settings.js";
+const MAX_HISTORY = 200;
+function historyPath() {
+    return path.join(getConfigDir(), "history.json");
+}
+/** Prompt history shared across sessions, oldest first (like shell history). */
+export function loadPromptHistory() {
+    try {
+        const data = JSON.parse(fs.readFileSync(historyPath(), "utf8"));
+        return Array.isArray(data) ? data.filter((e) => typeof e === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function appendPromptHistory(entry) {
+    try {
+        const history = loadPromptHistory();
+        // Like shells: skip consecutive duplicates.
+        if (history[history.length - 1] === entry)
+            return;
+        history.push(entry);
+        fs.mkdirSync(getConfigDir(), { recursive: true });
+        fs.writeFileSync(historyPath(), JSON.stringify(history.slice(-MAX_HISTORY), null, "\t") + "\n", {
+            mode: 0o600,
+        });
+    }
+    catch {
+        // history is best-effort
+    }
+}

package/dist/config/settings.js

@@ -0,0 +1,112 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { DEFAULT_MODEL_ID, isValidAxonModel, registerCustomModels } from "../api/models.js";
+const DEFAULTS = {
+    model: DEFAULT_MODEL_ID,
+    autoApproveEdits: false,
+    autoApproveSafeCommands: false,
+};
+/** Keys that settings.json files may set, in increasing precedence order. */
+const SETTINGS_KEYS = [
+    "model",
+    "organizationId",
+    "autoApproveEdits",
+    "autoApproveSafeCommands",
+    "baseUrl",
+    "apiKey",
+    "env",
+];
+export function getConfigDir() {
+    return process.env.ORBCODE_CONFIG_DIR || path.join(os.homedir(), ".orbcode");
+}
+function getConfigPath() {
+    return path.join(getConfigDir(), "config.json");
+}
+/** settings.json locations, lowest precedence first: user, then project. */
+export function getSettingsPaths(cwd = process.cwd()) {
+    return [path.join(getConfigDir(), "settings.json"), path.join(cwd, ".orbcode", "settings.json")];
+}
+function readJson(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Make sure ~/.orbcode/settings.json exists (empty JSON) so users can find it. */
+function ensureUserSettingsFile() {
+    try {
+        const settingsPath = path.join(getConfigDir(), "settings.json");
+        if (!fs.existsSync(settingsPath)) {
+            fs.mkdirSync(getConfigDir(), { recursive: true });
+            fs.writeFileSync(settingsPath, "{}\n", { mode: 0o600 });
+        }
+    }
+    catch {
+        // best-effort; loadSettings works without the file
+    }
+}
+export function loadSettings() {
+    ensureUserSettingsFile();
+    const settings = { ...DEFAULTS, ...readJson(getConfigPath()) };
+    // Layer settings.json files on top (user config dir, then project).
+    const customModels = [];
+    for (const settingsPath of getSettingsPaths()) {
+        const fileSettings = readJson(settingsPath);
+        if (!fileSettings)
+            continue;
+        for (const key of SETTINGS_KEYS) {
+            if (fileSettings[key] !== undefined) {
+                ;
+                settings[key] = fileSettings[key];
+            }
+        }
+        if (Array.isArray(fileSettings.customModels)) {
+            customModels.push(...fileSettings.customModels);
+        }
+    }
+    if (customModels.length > 0) {
+        settings.customModels = customModels;
+        registerCustomModels(customModels);
+    }
+    // env block from settings.json applies to this process.
+    if (settings.env && typeof settings.env === "object") {
+        for (const [key, value] of Object.entries(settings.env)) {
+            if (typeof value === "string")
+                process.env[key] = value;
+        }
+    }
+    // Environment variables take precedence over all files.
+    if (process.env.ORBCODE_BASE_URL)
+        settings.baseUrl = process.env.ORBCODE_BASE_URL;
+    if (process.env.ORBCODE_API_KEY)
+        settings.apiKey = process.env.ORBCODE_API_KEY;
+    if (process.env.ORBCODE_MODEL)
+        settings.model = process.env.ORBCODE_MODEL;
+    if (!isValidAxonModel(settings.model)) {
+        settings.model = DEFAULT_MODEL_ID;
+    }
+    return settings;
+}
+/**
+ * Effective credential: ORBCODE_TOKEN env > apiKey (settings.json / env) >
+ * stored login token.
+ */
+export function getAuthToken(settings) {
+    return process.env.ORBCODE_TOKEN || settings.apiKey || settings.token;
+}
+/** Persist app state to config.json. settings.json-only fields are skipped. */
+export function saveSettings(settings) {
+    const dir = getConfigDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const toPersist = {
+        token: settings.token,
+        model: settings.model,
+        organizationId: settings.organizationId,
+        autoApproveEdits: settings.autoApproveEdits,
+        autoApproveSafeCommands: settings.autoApproveSafeCommands,
+    };
+    fs.writeFileSync(getConfigPath(), JSON.stringify(toPersist, null, "\t") + "\n", { mode: 0o600 });
+}