pi-provider-kimi-code 0.6.1 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-provider-kimi-code",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Use Kimi Code in Pi without losing the Kimi-specific bits",
   "keywords": [
     "ai-provider",
@@ -50,9 +50,9 @@
     "pre-commit": "prek run"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.78.0",
-    "@earendil-works/pi-coding-agent": "^0.78.0",
-    "@earendil-works/pi-tui": "^0.78.1",
+    "@earendil-works/pi-ai": "^0.79.10",
+    "@earendil-works/pi-coding-agent": "^0.79.10",
+    "@earendil-works/pi-tui": "^0.79.10",
     "@j178/prek": "^0.4.4",
     "@types/node": "^24.0.0",
     "oxfmt": "^0.44.0",

package/src/config.ts

@@ -9,6 +9,8 @@ export type KimiToolName = (typeof KIMI_TOOL_NAMES)[number];
 
 export type KimiConfigSource = "runtime" | "env" | "project" | "home" | "default";
 
+export const PI_CONFIG_DIR_NAME = ".pi";
+
 export type KimiInputModality = "text" | "image" | "video";
 
 export interface ModelReasoningEntry {
@@ -83,6 +85,7 @@ export interface LoadKimiCodeConfigOptions {
   cwd: string;
   home: string;
   env?: NodeJS.ProcessEnv;
+  includeProject?: boolean;
 }
 
 export class ConfigError extends Error {
@@ -147,11 +150,11 @@ export function getRuntimeKimiCodeConfigOverride(): KimiCodeConfigPatch {
 }
 
 export function getGlobalKimiCodeConfigPath(home: string): string {
-  return join(home, ".pi", "providers", PROVIDER_ID, "config.json");
+  return join(home, PI_CONFIG_DIR_NAME, "providers", PROVIDER_ID, "config.json");
 }
 
 export function getProjectKimiCodeConfigPath(cwd: string): string {
-  return join(cwd, ".pi", "providers", PROVIDER_ID, "config.json");
+  return join(cwd, PI_CONFIG_DIR_NAME, "providers", PROVIDER_ID, "config.json");
 }
 
 export function kimiCodeConfigPath(home: string): string {
@@ -483,15 +486,23 @@ function buildSources(
 function loadLayers(
   options: LoadKimiCodeConfigOptions,
 ): Array<{ source: KimiConfigSource; config: Record<string, unknown> }> {
-  return [
+  const layers: Array<{ source: KimiConfigSource; config: Record<string, unknown> }> = [
     { source: "home", config: readConfigFile(getGlobalKimiCodeConfigPath(options.home)) },
-    { source: "project", config: readConfigFile(getProjectKimiCodeConfigPath(options.cwd)) },
+  ];
+  if (options.includeProject !== false) {
+    layers.push({
+      source: "project",
+      config: readConfigFile(getProjectKimiCodeConfigPath(options.cwd)),
+    });
+  }
+  layers.push(
     {
       source: "env",
       config: envConfigPatch(options.env ?? process.env) as Record<string, unknown>,
     },
     { source: "runtime", config: runtimeOverride as Record<string, unknown> },
-  ];
+  );
+  return layers;
 }
 
 export function loadKimiCodeConfig(

package/src/constants.ts

@@ -41,8 +41,13 @@ export function getDefaultBaseUrl(protocol: KimiWireProtocol): string {
 
 export const DEFAULT_BASE_URL = getDefaultBaseUrl(ENV_KIMI_CODE_PROTOCOL);
 
-export const KIMI_CODE_VERSION = "0.6.0";
-export const KIMI_CODE_USER_AGENT = `kimi-code-cli/${KIMI_CODE_VERSION}`;
+export const PROVIDER_VERSION = "0.6.3";
+
+// Upstream kimi-code CLI version — used in User-Agent and X-Msh-Version
+// headers to match the official client's identity. Update this when
+// syncing with https://github.com/anthropics/kimi-code.
+export const KIMI_UPSTREAM_VERSION = "0.18.0";
+export const KIMI_CODE_USER_AGENT = `kimi-code-cli/${KIMI_UPSTREAM_VERSION}`;
 export const KIMI_PLATFORM = "kimi_code_cli";
 
 export function getKimiCodeHome(): string {

package/src/device.ts

@@ -11,7 +11,7 @@ import { dirname } from "node:path";
 import {
   DEVICE_ID_PATH,
   KIMI_CODE_USER_AGENT,
-  KIMI_CODE_VERSION,
+  KIMI_UPSTREAM_VERSION,
   KIMI_PLATFORM,
 } from "./constants.ts";
 
@@ -156,7 +156,7 @@ export function getCommonHeaders(): Record<string, string> {
   const headers = {
     "User-Agent": KIMI_CODE_USER_AGENT,
     "X-Msh-Platform": KIMI_PLATFORM,
-    "X-Msh-Version": KIMI_CODE_VERSION,
+    "X-Msh-Version": KIMI_UPSTREAM_VERSION,
     "X-Msh-Device-Name": os.hostname(),
     "X-Msh-Device-Model": DEVICE_MODEL,
     "X-Msh-Os-Version": getOsVersion(),

package/src/project-trust.ts

@@ -0,0 +1,24 @@
+export async function isKimiProjectConfigApproved(ctx: unknown, cwd: string): Promise<boolean> {
+  const check = (ctx as { isProjectTrusted?: () => boolean } | undefined)?.isProjectTrusted;
+  if (typeof check !== "function") return true;
+
+  let sessionTrusted: boolean;
+  try {
+    sessionTrusted = check.call(ctx);
+  } catch {
+    return false;
+  }
+  if (!sessionTrusted) return false;
+
+  const mod = (await import("@earendil-works/pi-coding-agent")) as unknown as {
+    ProjectTrustStore?: new (agentDir: string) => { get(cwd: string): boolean | null };
+    getAgentDir?: () => string;
+  };
+  if (!mod.ProjectTrustStore || !mod.getAgentDir) return true;
+
+  try {
+    return new mod.ProjectTrustStore(mod.getAgentDir()).get(cwd) === true;
+  } catch {
+    return false;
+  }
+}

package/src/settings-ui.ts

@@ -0,0 +1,204 @@
+import os from "node:os";
+import { relative } from "node:path";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { SettingsListTheme } from "@earendil-works/pi-tui";
+
+import {
+  type KimiCodeConfig,
+  type KimiCodeConfigSources,
+  KIMI_TOOL_NAMES,
+  type KimiToolName,
+  getGlobalKimiCodeConfigPath,
+  getProjectKimiCodeConfigPath,
+} from "./config.ts";
+import { PROVIDER_VERSION } from "./constants.ts";
+import type { KimiOAuthExtras } from "./models.ts";
+
+export type KimiConfigScope = "project" | "home";
+
+export function moonshotStatus(config: KimiCodeConfig): string {
+  return KIMI_TOOL_NAMES.map((toolName) => {
+    const tool = config.tools[toolName];
+    const enabled = tool.enabled ? "enabled" : "disabled";
+    const collapsed = tool.default_collapsed ? "collapsed" : "expanded";
+    return `${toolName}: ${enabled}, default ${collapsed}`;
+  }).join("\n");
+}
+
+export function toggleEnabled(config: KimiCodeConfig, toolName: KimiToolName): KimiCodeConfig {
+  return {
+    ...config,
+    tools: {
+      ...config.tools,
+      [toolName]: {
+        ...config.tools[toolName],
+        enabled: !config.tools[toolName].enabled,
+      },
+    },
+  };
+}
+
+export function toggleCollapsed(config: KimiCodeConfig, toolName: KimiToolName): KimiCodeConfig {
+  return {
+    ...config,
+    tools: {
+      ...config.tools,
+      [toolName]: {
+        ...config.tools[toolName],
+        default_collapsed: !config.tools[toolName].default_collapsed,
+      },
+    },
+  };
+}
+
+export function setProtocol(
+  config: KimiCodeConfig,
+  protocol: KimiCodeConfig["protocol"],
+): KimiCodeConfig {
+  return { ...config, protocol };
+}
+
+export function setUploadThreshold(config: KimiCodeConfig, thresholdBytes: number): KimiCodeConfig {
+  return { ...config, uploads: { ...config.uploads, thresholdBytes } };
+}
+
+export function buildKimiMainTitle(
+  config: KimiCodeConfig,
+  extras: KimiOAuthExtras,
+  sources: KimiCodeConfigSources,
+): string {
+  const modelName = extras.modelDisplay || "kimi-for-coding";
+  return [
+    `Kimi settings (provider v${PROVIDER_VERSION})`,
+    "",
+    `Model: ${modelName}`,
+    `Protocol: ${config.protocol} (${sources.protocol})`,
+    `Upload threshold: ${formatByteSize(config.uploads.thresholdBytes)} (${sources.uploads.thresholdBytes})`,
+    "",
+    "Effective tools:",
+    ...KIMI_TOOL_NAMES.map((toolName) => {
+      const enabled = config.tools[toolName].enabled ? "enabled" : "disabled";
+      return `- ${toolName}: ${enabled} (${sources.tools[toolName].enabled})`;
+    }),
+  ].join("\n");
+}
+
+export function buildConfigScopeTitle(
+  scope: KimiConfigScope,
+  config: KimiCodeConfig,
+  filePath: string,
+): string {
+  return [
+    `Edit ${scope} config`,
+    `File: ${filePath}`,
+    "",
+    formatProtocolStatus(config),
+    formatUploadThresholdStatus(config),
+    "",
+    moonshotStatus(config),
+  ].join("\n");
+}
+
+export function buildSettingsTheme(theme: Theme): SettingsListTheme {
+  return {
+    label: (text: string, selected: boolean) => (selected ? theme.fg("accent", text) : text),
+    value: (text: string, selected: boolean) =>
+      selected ? theme.bold(theme.fg("accent", text)) : theme.fg("muted", text),
+    description: (text: string) => theme.fg("dim", text),
+    cursor: theme.fg("accent", "> "),
+    hint: (text: string) => theme.fg("dim", text),
+  };
+}
+
+export function formatScopeDescription(
+  scope: KimiConfigScope,
+  cwd: string,
+  home = os.homedir(),
+): string {
+  const filePath =
+    scope === "project" ? getProjectKimiCodeConfigPath(cwd) : getGlobalKimiCodeConfigPath(home);
+  const displayPath = scope === "home" ? homeRelative(filePath, home) : relative(cwd, filePath);
+  return `Writes to the ${scope} config file: ${displayPath}`;
+}
+
+export function homeRelative(filePath: string, home = os.homedir()): string {
+  const normalizedHome = home.replace(/[\\/]+$/, "");
+  if (filePath === normalizedHome) return "~";
+
+  const slashPrefix = `${normalizedHome}/`;
+  if (filePath.startsWith(slashPrefix)) return `~/${filePath.slice(slashPrefix.length)}`;
+
+  const backslashPrefix = `${normalizedHome}\\`;
+  if (filePath.startsWith(backslashPrefix)) return `~\\${filePath.slice(backslashPrefix.length)}`;
+
+  return filePath;
+}
+
+export function toolMenuItem(config: KimiCodeConfig, toolName: KimiToolName): string {
+  return `${toolName} -> ${formatToolStatus(config, toolName)}`;
+}
+
+export function protocolMenuItem(config: KimiCodeConfig): string {
+  return `Protocol -> ${config.protocol}`;
+}
+
+export function uploadThresholdMenuItem(config: KimiCodeConfig): string {
+  return `Upload threshold -> ${formatByteSize(config.uploads.thresholdBytes)}`;
+}
+
+export function formatByteSize(bytes: number): string {
+  const units = [
+    { suffix: "GiB", size: 1024 ** 3 },
+    { suffix: "MiB", size: 1024 ** 2 },
+    { suffix: "KiB", size: 1024 },
+  ];
+  for (const unit of units) {
+    if (bytes >= unit.size && bytes % unit.size === 0) {
+      return `${bytes / unit.size} ${unit.suffix}`;
+    }
+  }
+  for (const unit of units) {
+    if (bytes >= unit.size) {
+      return `${(bytes / unit.size).toFixed(2).replace(/\.00$/, "")} ${unit.suffix}`;
+    }
+  }
+  return `${bytes} B`;
+}
+
+export function parseByteSizeInput(input: string): number | undefined {
+  const match = input.trim().match(/^(\d+(?:\.\d+)?)\s*(b|bytes?|kib|kb|mib|mb|gib|gb)?$/i);
+  if (!match) return undefined;
+  const value = Number(match[1]);
+  if (!Number.isFinite(value) || value <= 0) return undefined;
+  const unit = (match[2] ?? "mib").toLowerCase();
+  const multipliers: Record<string, number> = {
+    b: 1,
+    byte: 1,
+    bytes: 1,
+    kib: 1024,
+    kb: 1000,
+    mib: 1024 ** 2,
+    mb: 1000 ** 2,
+    gib: 1024 ** 3,
+    gb: 1000 ** 3,
+  };
+  const multiplier = multipliers[unit];
+  if (!multiplier) return undefined;
+  const bytes = Math.round(value * multiplier);
+  return Number.isSafeInteger(bytes) && bytes > 0 ? bytes : undefined;
+}
+
+export function formatProtocolStatus(config: KimiCodeConfig): string {
+  return `protocol: ${config.protocol}`;
+}
+
+export function formatUploadThresholdStatus(config: KimiCodeConfig): string {
+  return `upload threshold: ${formatByteSize(config.uploads.thresholdBytes)}`;
+}
+
+export function formatToolStatus(config: KimiCodeConfig, toolName: KimiToolName): string {
+  const tool = config.tools[toolName];
+  const enabled = tool.enabled ? "enabled" : "disabled";
+  const collapsed = tool.default_collapsed ? "default collapsed" : "default expanded";
+  return `${enabled}, ${collapsed}`;
+}

package/src/usage.ts

@@ -0,0 +1,274 @@
+import { AuthStorage } from "@earendil-works/pi-coding-agent";
+
+import { PROVIDER_ID, getBaseUrl } from "./constants.ts";
+import { getCommonHeaders } from "./device.ts";
+import { refreshKimiAuthToken } from "./oauth.ts";
+
+const MEMBERSHIP_LEVEL_NAMES: Record<string, string> = {
+  LEVEL_FREE: "Free",
+  LEVEL_BASIC: "Adagio",
+  LEVEL_STANDARD: "Moderato",
+  LEVEL_INTERMEDIATE: "Allegretto",
+  LEVEL_ADVANCED: "Allegro",
+  LEVEL_PREMIUM: "Vivace",
+};
+
+const RESET_TIME_KEYS = [
+  "resetTime",
+  "reset_time",
+  "resetAt",
+  "reset_at",
+  "resetsAt",
+  "resets_at",
+  "nextResetTime",
+  "next_reset_time",
+] as const;
+
+export interface UsageRow {
+  label: string;
+  used: number;
+  limit: number;
+  resetTime?: string;
+}
+
+export interface UsageFormatOptions {
+  now?: Date;
+  timeZone?: string;
+}
+
+export function getKimiUsageToken(): string | null {
+  const credential = AuthStorage.create().get(PROVIDER_ID);
+  if (credential?.type === "oauth" && credential.access) return credential.access;
+  const apiKey = process.env.KIMI_API_KEY?.trim();
+  return apiKey || null;
+}
+
+function toNumber(value: unknown): number | null {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
+function toStringValue(value: unknown): string | undefined {
+  if (typeof value === "string" && value.trim()) return value;
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return undefined;
+}
+
+function getResetTime(record: Record<string, unknown>): string | undefined {
+  for (const key of RESET_TIME_KEYS) {
+    const value = toStringValue(record[key]);
+    if (value) return value;
+  }
+  return undefined;
+}
+
+export function parseUsageRow(value: unknown, fallbackLabel: string): UsageRow | null {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value as Record<string, unknown>;
+  const limit = toNumber(record.limit);
+  const usedValue = toNumber(record.used);
+  const remaining = toNumber(record.remaining);
+  const used = usedValue ?? (limit !== null && remaining !== null ? limit - remaining : null);
+  if (limit === null && used === null) return null;
+  return {
+    label: String(record.name || record.title || fallbackLabel),
+    used: used ?? 0,
+    limit: limit ?? 0,
+    ...(getResetTime(record) ? { resetTime: getResetTime(record) } : {}),
+  };
+}
+
+export function parseUsageSummary(payload: unknown, options: UsageFormatOptions = {}): string {
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+    return "Usage: unavailable";
+  }
+
+  const record = payload as Record<string, unknown>;
+  const lines: string[] = [];
+  const membership = parseMembership(record);
+  if (membership) lines.push(membership, "");
+
+  const summary = parseUsageRow(record.usage, "Current week");
+  if (summary)
+    lines.push(formatUsageRow({ ...summary, label: normalizeUsageLabel(summary.label) }, options));
+
+  if (Array.isArray(record.limits)) {
+    for (const [index, item] of record.limits.entries()) {
+      const itemRecord =
+        typeof item === "object" && item !== null && !Array.isArray(item)
+          ? (item as Record<string, unknown>)
+          : undefined;
+      const detail = itemRecord ? (itemRecord.detail ?? itemRecord) : item;
+      const fallbackLabel = itemRecord
+        ? formatWindowLabel(
+            itemRecord.window,
+            index === 0 ? "Current 5h window" : `Limit #${index + 1}`,
+          )
+        : index === 0
+          ? "Current 5h window"
+          : `Limit #${index + 1}`;
+      const row = parseUsageRow(detail, fallbackLabel);
+      if (row) {
+        if (lines.length > 0) lines.push("");
+        lines.push(formatUsageRow(row, options));
+      }
+    }
+  }
+
+  while (lines.at(-1) === "") lines.pop();
+  return lines.length === 0 ? "Usage: no usage data" : lines.join("\n");
+}
+
+function normalizeUsageLabel(label: string): string {
+  return /weekly|week/i.test(label) ? "Current week" : label;
+}
+
+function formatWindowLabel(value: unknown, fallbackLabel: string): string {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return fallbackLabel;
+  const record = value as Record<string, unknown>;
+  const duration = toNumber(record.duration);
+  const unit = String(record.timeUnit ?? record.time_unit ?? "").toUpperCase();
+  if (!duration || !unit) return fallbackLabel;
+
+  const minutes = unit.includes("HOUR")
+    ? duration * 60
+    : unit.includes("MINUTE")
+      ? duration
+      : undefined;
+  if (!minutes) return fallbackLabel;
+  if (minutes % 60 === 0) return `Current ${minutes / 60}h window`;
+  return `Current ${minutes}m window`;
+}
+
+export function parseMembership(record: Record<string, unknown>): string | null {
+  const user = record.user;
+  if (typeof user !== "object" || user === null || Array.isArray(user)) return null;
+  const membership = (user as Record<string, unknown>).membership;
+  if (typeof membership !== "object" || membership === null || Array.isArray(membership)) {
+    return null;
+  }
+  const level = (membership as Record<string, unknown>).level;
+  if (typeof level !== "string" || !level) return null;
+  const name = MEMBERSHIP_LEVEL_NAMES[level];
+  return name ? `Membership: ${name} (${level})` : `Membership: ${level}`;
+}
+
+export function formatUsageRow(row: UsageRow, options: UsageFormatOptions = {}): string {
+  if (row.limit <= 0) return `${row.label}\n${row.used} used`;
+  const used = Math.max(0, Math.min(row.used, row.limit));
+  const percent = Math.round((used / row.limit) * 100);
+  const lines = [row.label, `${quotaBar(used, row.limit)} ${percent}% used`];
+  const reset = formatResetTime(row.resetTime, options);
+  if (reset) lines.push(`Resets ${reset}`);
+  return lines.join("\n");
+}
+
+export function formatResetTime(value: unknown, options: UsageFormatOptions = {}): string | null {
+  const text = toStringValue(value);
+  if (!text) return null;
+  const date = parseDate(text);
+  if (!date) return null;
+
+  const now = options.now ?? new Date();
+  const timeZone = options.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC";
+  const sameDay = datePart(date, timeZone) === datePart(now, timeZone);
+  const time = formatTime(date, timeZone);
+  const prefix = sameDay ? "" : `${formatMonthDay(date, timeZone)} at `;
+  return `${prefix}${time} (${timeZone})`;
+}
+
+function parseDate(value: string): Date | null {
+  const timestamp = /^\d+$/.test(value) ? Number(value) : Number.NaN;
+  const date = Number.isFinite(timestamp)
+    ? new Date(timestamp < 1_000_000_000_000 ? timestamp * 1000 : timestamp)
+    : new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function datePart(date: Date, timeZone: string): string {
+  return new Intl.DateTimeFormat("en-US", {
+    day: "2-digit",
+    month: "2-digit",
+    timeZone,
+    year: "numeric",
+  }).format(date);
+}
+
+function formatMonthDay(date: Date, timeZone: string): string {
+  return new Intl.DateTimeFormat("en-US", {
+    day: "numeric",
+    month: "short",
+    timeZone,
+  }).format(date);
+}
+
+function formatTime(date: Date, timeZone: string): string {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    hour: "numeric",
+    hour12: true,
+    minute: "2-digit",
+    timeZone,
+  }).formatToParts(date);
+  const hour = parts.find((part) => part.type === "hour")?.value ?? "";
+  const minute = parts.find((part) => part.type === "minute")?.value ?? "";
+  const dayPeriod = parts.find((part) => part.type === "dayPeriod")?.value.toLowerCase() ?? "";
+  return `${hour}:${minute}${dayPeriod}`;
+}
+
+function quotaBar(used: number, limit: number): string {
+  const width = 50;
+  const ratio = Math.max(0, Math.min(1, used / limit));
+  const filled = Math.floor(ratio * width);
+  const partial = partialBlock(ratio * width - filled);
+  const empty = width - filled - (partial ? 1 : 0);
+  return `${"█".repeat(filled)}${partial}${" ".repeat(Math.max(0, empty))}`;
+}
+
+function partialBlock(value: number): string {
+  if (value < 0.125) return "";
+  if (value < 0.25) return "▏";
+  if (value < 0.375) return "▎";
+  if (value < 0.5) return "▍";
+  if (value < 0.625) return "▌";
+  if (value < 0.75) return "▋";
+  if (value < 0.875) return "▊";
+  return "▉";
+}
+
+export function buildKimiUsageUrl(baseUrl = getBaseUrl("openai")): string {
+  const normalized = baseUrl.replace(/\/+$/, "");
+  return normalized.endsWith("/v1") ? `${normalized}/usages` : `${normalized}/v1/usages`;
+}
+
+function fetchKimiUsage(token: string, signal: AbortSignal): Promise<Response> {
+  return fetch(buildKimiUsageUrl(), {
+    method: "GET",
+    headers: {
+      ...getCommonHeaders(),
+      Authorization: `Bearer ${token}`,
+    },
+    signal,
+  });
+}
+
+export async function fetchKimiUsageSummary(): Promise<string> {
+  const token = getKimiUsageToken();
+  if (!token) return "Usage: missing credentials. Run /login kimi-coding.";
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 15_000);
+  try {
+    let response = await fetchKimiUsage(token, controller.signal);
+    if (response.status === 401) {
+      const refreshed = await refreshKimiAuthToken(token);
+      if (refreshed) response = await fetchKimiUsage(refreshed, controller.signal);
+    }
+    if (!response.ok) return `Usage: fetch failed (${response.status})`;
+    return parseUsageSummary(await response.json());
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `Usage: fetch failed (${message})`;
+  } finally {
+    clearTimeout(timeout);
+  }
+}