@botconnector/bccli 0.4.0 → 0.4.1

package/dist/sdk.js

@@ -715,21 +715,46 @@ function loadConfig(cwd, env = process.env) {
     allow: [...global.allow ?? []]
   };
 }
+function writeFileAtomic(path, data, mode) {
+  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync(tmp, data, mode === void 0 ? void 0 : { mode });
+    renameSync(tmp, path);
+    if (mode !== void 0) chmodSync(path, mode);
+  } catch (error) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function quarantineCorruptFile(path, error) {
+  const stamp = Date.now();
+  let dest = `${path}.corrupt-${stamp}`;
+  for (let n = 1; existsSync(dest); n++) dest = `${path}.corrupt-${stamp}-${n}`;
+  try {
+    renameSync(path, dest);
+  } catch {
+    return void 0;
+  }
+  console.error(`${path} is not valid JSON (${error.message}); moved it to ${dest} instead of overwriting it.`);
+  return dest;
+}
 function readCredentials(env = process.env) {
   const path = join(bccliHome(env), "credentials");
   if (!existsSync(path)) return {};
   try {
     return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
+  } catch (error) {
+    quarantineCorruptFile(path, error);
     return {};
   }
 }
 function saveCredential(providerId, key, env = process.env) {
   const home = bccliHome(env);
   mkdirSync(home, { recursive: true });
-  const path = join(home, "credentials");
-  writeFileSync(path, JSON.stringify({ ...readCredentials(env), [providerId]: key }, null, 2), { mode: 384 });
-  chmodSync(path, 384);
+  writeFileAtomic(join(home, "credentials"), JSON.stringify({ ...readCredentials(env), [providerId]: key }, null, 2), 384);
 }
 function resolveModel(config, modelRef, env = process.env) {
   const slash = modelRef.indexOf("/");
@@ -765,8 +790,43 @@ function isAlwaysAsk(segment) {
   }
   return false;
 }
+var RUNNER_COMMANDS = /* @__PURE__ */ new Set([
+  "npm",
+  "npx",
+  "pnpm",
+  "pnpx",
+  "yarn",
+  "bun",
+  "bunx",
+  "deno",
+  "node",
+  "tsx",
+  "ts-node",
+  "python",
+  "python3",
+  "py",
+  "uv",
+  "uvx",
+  "pip",
+  "pip3",
+  "pipx",
+  "pytest",
+  "make",
+  "cargo",
+  "go",
+  "dotnet",
+  "java",
+  "ruby",
+  "bundle",
+  "rake",
+  "gradle",
+  "mvn",
+  "php",
+  "composer"
+]);
 function commandKey(segment) {
   const words2 = segment.trim().split(/\s+/);
+  if (RUNNER_COMMANDS.has(words2[0] ?? "") && words2[2] && !words2[2].startsWith("-")) return words2.slice(0, 3).join(" ");
   return words2[1] ? `${words2[0]} ${words2[1]}` : words2[0];
 }
 function requiresSensitiveToolApproval(req) {
@@ -1748,7 +1808,7 @@ function createProvider(options) {
   const isBotConnectorCloud = /^https:\/\/api\.botconnector\.id\/v1\/?$/.test(baseURL) && apiKey?.startsWith("bc_live_");
   if (isBotConnectorCloud) {
     headers["x-botconnector-client"] = "bccli";
-    headers["x-botconnector-client-version"] = "0.4.0";
+    headers["x-botconnector-client-version"] = "0.4.1";
   }
   const useNativeResponses = isBotConnectorCloud && providerId === "bc-cloud" && model === "gpt-6-luna";
   const useResponsesWebSocket = useNativeResponses && Boolean(apiKey) && (fetchOverride === void 0 || responsesWebSocketFactory !== void 0);
@@ -1779,7 +1839,7 @@ function createProvider(options) {
         baseURL: baseURL.replace(/\/+$/, ""),
         defaultHeaders: {
           "x-botconnector-client": "bccli",
-          "x-botconnector-client-version": "0.4.0"
+          "x-botconnector-client-version": "0.4.1"
         }
       });
       lunaWs = responsesWebSocketFactory ? responsesWebSocketFactory(client) : new ResponsesWS(client, { reconnect: null });
@@ -1842,8 +1902,13 @@ function createProvider(options) {
       } catch (error) {
         const err = error instanceof ProviderError ? error : new ProviderError(error.message);
         const lostPrevious = err.code === "previous_response_not_found";
+        const handshakeStatus = /unexpected server response:\s*(\d{3})\b/i.exec(err.message);
+        const handshakeRejected = Boolean(handshakeStatus && Number(handshakeStatus[1]) >= 400);
         const connectionLost = /websocket|connection closed|socket|network/i.test(err.message) || err.code === "websocket_connection_limit_reached";
         resetLunaWebSocket();
+        if (!emittedText && !signal?.aborted && handshakeRejected) {
+          throw new ProviderError(err.message, Number(handshakeStatus?.[1]), "bc_ws_http_fallback");
+        }
         if (attempt === 0 && !emittedText && !signal?.aborted && (plan.incremental || lostPrevious || connectionLost)) {
           continue;
         }
@@ -1870,7 +1935,8 @@ function createProvider(options) {
       if (res.ok) return res;
       const text = await res.text().catch(() => "");
       lastError = new ProviderError(t("{status} from {url}: {message}", { status: res.status, url: baseURL, message: errorMessage(text) }), res.status);
-      if (!retryable(res.status)) throw lastError;
+      const deterministicQuota429 = res.status === 429 && /"code"\s*:\s*"(?:luna_monthly_quota_exhausted|plan_allowance_exhausted)"/i.test(text);
+      if (!retryable(res.status) || deterministicQuota429) throw lastError;
     }
     throw lastError ?? new ProviderError(t("Request failed"));
   }
@@ -3897,7 +3963,7 @@ import { z as z9 } from "zod";
 
 // src/mcp/config.ts
 import { createHash } from "crypto";
-import { chmodSync as chmodSync2, existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync3 } from "fs";
 import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
 var ENV_REF = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
 function expandEnvVars(config, env) {
@@ -3920,7 +3986,7 @@ function expandEnvVars(config, env) {
 
 // src/mcp/oauth.ts
 import { spawn as spawn3 } from "child_process";
-import { chmodSync as chmodSync3, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync4 } from "fs";
 import { createServer } from "http";
 import { dirname as dirname4, join as join4 } from "path";
 import { auth } from "@modelcontextprotocol/sdk/client/auth.js";
@@ -3930,23 +3996,29 @@ function readStore(home) {
   if (!existsSync7(path)) return {};
   try {
     return JSON.parse(readFileSync4(path, "utf8"));
-  } catch {
+  } catch (error) {
+    quarantineCorruptFile(path, error);
     return {};
   }
 }
 function writeStore(home, store) {
   const path = oauthStorePath(home);
   mkdirSync3(dirname4(path), { recursive: true });
-  writeFileSync3(path, `${JSON.stringify(store, null, 2)}
-`, { mode: 384 });
-  chmodSync3(path, 384);
+  writeFileAtomic(path, `${JSON.stringify(store, null, 2)}
+`, 384);
 }
 function hasStoredTokens(home, serverUrl) {
   return Boolean(readStore(home)[serverUrl]?.tokens);
 }
-function defaultOpen(url) {
-  const target = url.href;
-  const child = process.platform === "win32" ? spawn3("cmd", ["/c", "start", "", target], { detached: true, stdio: "ignore" }) : spawn3(process.platform === "darwin" ? "open" : "xdg-open", [target], { detached: true, stdio: "ignore" });
+function openCommand(url, platform) {
+  if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+  if (platform === "win32") return { command: "rundll32.exe", args: ["url.dll,FileProtocolHandler", url.href] };
+  return { command: platform === "darwin" ? "open" : "xdg-open", args: [url.href] };
+}
+function defaultOpen(url, deps = {}) {
+  const plan = openCommand(url, deps.platform ?? process.platform);
+  if (!plan) return;
+  const child = (deps.spawn ?? spawn3)(plan.command, plan.args, { detached: true, stdio: "ignore" });
   child.unref();
   child.on("error", () => {
   });
@@ -4193,7 +4265,7 @@ import { homedir as homedir2 } from "os";
 // src/context.ts
 import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
 import { dirname as dirname5, join as join5 } from "path";
-var FILES = ["AGENTS.md", "BCCLI.md"];
+var FILES = ["AGENTS.md", "CLAUDE.md", "BCCLI.md"];
 function readIf(path) {
   try {
     return existsSync8(path) ? readFileSync5(path, "utf8").trim() : void 0;
@@ -4346,7 +4418,7 @@ function loadAgentDefs(r) {
 }
 
 // src/providers.ts
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync2 } from "fs";
 import { join as join7 } from "path";
 function providerName(config, id) {
   return PRESETS.find((p) => p.id === id)?.name ?? config.providers[id]?.name ?? id;
@@ -4480,6 +4552,15 @@ var Session = class _Session {
     }
     return repairTail(messages);
   }
+  /** Model of the most recent turn that recorded usage — serve attach continues a session with its own model. */
+  lastModel() {
+    const records = this.records();
+    for (let i = records.length - 1; i >= 0; i--) {
+      const record = records[i];
+      if (record.t === "usage" && record.model) return record.model;
+    }
+    return void 0;
+  }
   /**
    * What the user sees on resume: the whole conversation. Compaction only shrinks what the model is sent, so
    * its reset does not hide the older turns here. A real reset (/clear, rewind) still starts over, the

package/dist/{serve-6QLBJUYW.js → serve-KWOECK5W.js}

@@ -8,7 +8,7 @@ import "./chunk-PSO7R5AD.js";
 import {
   loadConfig,
   readCredentials
-} from "./chunk-LACUWBWS.js";
+} from "./chunk-FLQPE4S5.js";
 import {
   t
 } from "./chunk-UZWJQF67.js";

package/dist/{serve-JG7RLIUD.js → serve-X2ZV4S5U.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   createRuntime
-} from "./chunk-TVALKHFB.js";
+} from "./chunk-PZRKU4UM.js";
 import "./chunk-QZKLZELZ.js";
-import "./chunk-M7CALSP3.js";
+import "./chunk-BGXNR74O.js";
 import "./chunk-45SDLMTV.js";
 import "./chunk-PSO7R5AD.js";
 import {
   VERSION
-} from "./chunk-6M5X2KZE.js";
+} from "./chunk-BKGFA2PT.js";
 import {
   LOOPBACK_BIND,
   MAX_FRAME_BYTES,
@@ -17,24 +17,24 @@ import {
   parseClientFrame,
   randomToken,
   trustFence
-} from "./chunk-KEMYIGCP.js";
-import "./chunk-O7M3TGIW.js";
-import "./chunk-JL5ZCSP2.js";
+} from "./chunk-XV7ZVL4J.js";
+import "./chunk-MHIYLXJC.js";
+import "./chunk-GN4W3T6E.js";
 import {
   listAllModels
-} from "./chunk-XBO5GACQ.js";
-import "./chunk-SPRNLS7K.js";
-import "./chunk-7F3IWBPQ.js";
+} from "./chunk-75BECX4F.js";
+import "./chunk-JHPGOAXU.js";
+import "./chunk-MFHCQQEN.js";
 import {
   Session
-} from "./chunk-QDQU6VY2.js";
-import "./chunk-PUN4HMAG.js";
+} from "./chunk-BC7UXFE4.js";
+import "./chunk-WNACAUDK.js";
 import "./chunk-BLOYFIAD.js";
-import "./chunk-L7QI6JN2.js";
+import "./chunk-24JN75FZ.js";
 import {
   bccliHome,
   loadConfig
-} from "./chunk-LACUWBWS.js";
+} from "./chunk-FLQPE4S5.js";
 import "./chunk-UZWJQF67.js";
 
 // src/serve.ts
@@ -101,6 +101,11 @@ function readBody(req) {
 function sendFrame(ws, frame) {
   if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(frame));
 }
+function serveBanner(handle, opts = {}) {
+  const supplied = opts.token !== void 0 || (opts.env ?? process.env).BCCLI_SERVE_TOKEN !== void 0;
+  return `bccli serve ${handle.url}${supplied ? "" : ` \u2014 Authorization: Bearer ${handle.token}`}
+`;
+}
 async function startServe(opts = {}) {
   const env = opts.env ?? process.env;
   const cwd = opts.cwd ?? process.cwd();
@@ -454,7 +459,7 @@ Connection: close\r
   function attachSession(id, forCwd) {
     const found = findSessionFile(id, forCwd);
     if (!found) return void 0;
-    const rt = buildRuntime(found.cwd, "ask");
+    const rt = buildRuntime(found.cwd, "ask", found.session.lastModel());
     rt.resume(found.session);
     return registerSession(rt, found.cwd, "ask", id);
   }
@@ -511,5 +516,6 @@ Connection: close\r
   };
 }
 export {
+  serveBanner,
   startServe
 };

package/dist/serve.d.ts

@@ -0,0 +1,37 @@
+import type { Provider } from './provider';
+export interface ServeOptions {
+    port?: number;
+    host?: string;
+    token?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    provider?: Provider;
+    fetch?: typeof fetch;
+    heartbeatMs?: number;
+    err?: (s: string) => void;
+}
+export interface ServeHandle {
+    port: number;
+    token: string;
+    url: string;
+    close(): Promise<void>;
+}
+export type PermissionMode = 'ask' | 'bypassPermissions';
+/**
+ * One-line terminal banner for `bccli serve`. A token the user supplied (`--token` or
+ * `BCCLI_SERVE_TOKEN`) is left out so it cannot leak into logs; a token BCCLI generated
+ * itself must be printed or nobody could connect.
+ */
+export declare function serveBanner(handle: {
+    url: string;
+    token: string;
+}, opts?: {
+    token?: string;
+    env?: NodeJS.ProcessEnv;
+}): string;
+/**
+ * Starts the loopback session server (HTTP unary + WS mux at /v1/mux). Refuses
+ * non-loopback bind addresses; every request passes the DSH-style trust fence
+ * (403) and, except /health, the bearer-token check (401).
+ */
+export declare function startServe(opts?: ServeOptions): Promise<ServeHandle>;

package/dist/serveHeartbeat.d.ts

@@ -0,0 +1,14 @@
+export interface Heartbeat {
+    /** Sends the first ping and schedules the check loop. Idempotent until stop(). */
+    start(): void;
+    /** Marks the last ping as answered (ws 'pong' event). */
+    pong(): void;
+    /** Clears the timer; no further pings or terminations. */
+    stop(): void;
+}
+/**
+ * ws heartbeat with deadline: every interval a ping goes out; a ping left
+ * unanswered by the next tick terminates the socket (connection, not stream).
+ * Modeled on the DSH gateway's `websocketHeartbeatIntervalMs` behavior.
+ */
+export declare function createHeartbeat(intervalMs: number, ping: () => void, terminate: () => void): Heartbeat;

package/dist/serveProtocol.d.ts

@@ -0,0 +1,47 @@
+/** Wire frames of the /v1/mux WebSocket (subset of the DSH stream protocol). */
+export type ClientFrame = {
+    type: 'open';
+    streamId: string;
+    target: string;
+} | {
+    type: 'cancel';
+    streamId: string;
+};
+export type ServerFrame = {
+    type: 'item';
+    streamId: string;
+    value: unknown;
+} | {
+    type: 'end';
+    streamId: string;
+} | {
+    type: 'error';
+    streamId: string;
+    message: string;
+};
+/** Uplink frame size limit; oversized frames error their stream without closing the socket. */
+export declare const MAX_FRAME_BYTES = 262144;
+/**
+ * Parses one uplink mux frame. Malformed JSON, unknown types, an empty streamId,
+ * or an `open` without a target produce `{ error }` instead of throwing.
+ */
+export declare function parseClientFrame(raw: string): ClientFrame | {
+    error: string;
+};
+/** Addresses `bccli serve` is allowed to bind (loopback only; 0.0.0.0 is refused). */
+export declare const LOOPBACK_BIND: Set<string>;
+/**
+ * DSH-style trust fence: loopback Host with a port matching the listener, a
+ * same-machine Origin when attached, and no cross-site sec-fetch-site. Returns
+ * null when trusted, else the 403 reason. Never establishes identity — the
+ * bearer token does.
+ */
+export declare function trustFence(headers: {
+    host?: string;
+    origin?: string;
+    'sec-fetch-site'?: string;
+}, port: number): string | null;
+/** Timing-safe `Authorization: Bearer <token>` check. */
+export declare function bearerOk(header: string | undefined, token: string): boolean;
+/** Fresh 32-byte hex serve token. */
+export declare function randomToken(): string;

package/dist/{session-KBAQ4BZ5.js → session-GKEXDJKZ.js}

@@ -2,8 +2,8 @@
 import {
   Session,
   pruneSessions
-} from "./chunk-QDQU6VY2.js";
-import "./chunk-PUN4HMAG.js";
+} from "./chunk-BC7UXFE4.js";
+import "./chunk-WNACAUDK.js";
 import "./chunk-BLOYFIAD.js";
 import "./chunk-UZWJQF67.js";
 export {

package/dist/session.d.ts

@@ -0,0 +1,30 @@
+import { type ChatMessage, type Usage } from './provider';
+export declare class Session {
+    readonly file: string;
+    constructor(file: string);
+    static create(home: string, cwd: string, now?: Date): Session;
+    static list(home: string, cwd: string): {
+        session: Session;
+        mtime: Date;
+        preview: string;
+    }[];
+    static latest(home: string, cwd: string): Session | undefined;
+    private write;
+    append(message: ChatMessage): void;
+    appendUsage(usage: Usage & {
+        model?: string;
+    }): void;
+    reset(): void;
+    private records;
+    /** What the model continues from: everything after the last reset (after a compaction that is the summary and the recent turns). */
+    load(): ChatMessage[];
+    /** Model of the most recent turn that recorded usage — serve attach continues a session with its own model. */
+    lastModel(): string | undefined;
+    /**
+     * What the user sees on resume: the whole conversation. Compaction only shrinks what the model is sent, so
+     * its reset does not hide the older turns here. A real reset (/clear, rewind) still starts over, the
+     * synthetic summary pair is never shown, and the recent turns a compaction re-writes are not shown twice.
+     */
+    loadHistory(): ChatMessage[];
+}
+export declare function pruneSessions(home: string, now?: number, maxAgeDays?: number): number;

package/dist/setup-OV3NWQN5.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import {
+  createRuntime,
+  lunaPtcAutoEnabled
+} from "./chunk-PZRKU4UM.js";
+import "./chunk-QZKLZELZ.js";
+import "./chunk-BGXNR74O.js";
+import "./chunk-45SDLMTV.js";
+import "./chunk-PSO7R5AD.js";
+import "./chunk-MHIYLXJC.js";
+import "./chunk-GN4W3T6E.js";
+import "./chunk-75BECX4F.js";
+import "./chunk-JHPGOAXU.js";
+import "./chunk-MFHCQQEN.js";
+import "./chunk-BC7UXFE4.js";
+import "./chunk-WNACAUDK.js";
+import "./chunk-BLOYFIAD.js";
+import "./chunk-24JN75FZ.js";
+import "./chunk-FLQPE4S5.js";
+import "./chunk-UZWJQF67.js";
+export {
+  createRuntime,
+  lunaPtcAutoEnabled
+};

package/dist/setup.d.ts

@@ -0,0 +1,74 @@
+import { Agent } from './agent';
+import { CheckpointStore } from './checkpoints';
+import type { McpServerSpec } from './mcp/config';
+import { McpManager } from './mcp/manager';
+import type { CliArgs } from './args';
+import { type Config } from './config';
+import { type AgentDef, type CommandDef, type SkillDef } from './extensions';
+import { type ModelGroup } from './models';
+import { type ChatMessage, type Provider } from './provider';
+import type { ReasoningLevel } from './reasoning';
+import { addProviderKey } from './providerCli';
+import { Session } from './session';
+import { type Interaction } from './tools/plan';
+import { TodoStore } from './tools/todo';
+import { type PluginPayload } from './plugins';
+import type { HookEvent } from './hooks';
+export interface Runtime {
+    cwd: string;
+    home: string;
+    config: Config;
+    modelRef: string;
+    reasoning: ReasoningLevel;
+    agent: Agent;
+    session: Session;
+    setModel(ref: string): void;
+    setReasoning(level: ReasoningLevel): void;
+    env: NodeJS.ProcessEnv;
+    skills: SkillDef[];
+    commands: CommandDef[];
+    agentDefs: AgentDef[];
+    todos: TodoStore;
+    interaction: Interaction;
+    mcp: McpManager;
+    startMcp(specs: McpServerSpec[]): Promise<void>;
+    reloadConfig(): void;
+    providerLabel(): string;
+    listModels: (only?: string) => Promise<ModelGroup[]>;
+    addProviderKey(id: string, key: string): ReturnType<typeof addProviderKey>;
+    /** Continue an earlier session: load its history and append new messages to its file. */
+    resume(session: Session): void;
+    /** Starts a fresh session file; the previous one stays on disk for /resume. */
+    newSession(): void;
+    /** Re-reads AGENTS.md/BCCLI.md into the system prompt (after /memory). */
+    rebuildSystemPrompt(): void;
+    /** Fires a plugin observer event (SessionStart/Stop are emitted here; tool events come from the agent). */
+    emitPlugins(event: HookEvent, payload?: PluginPayload): Promise<void>;
+    checkpoints: CheckpointStore;
+    /**
+     * Steps back n conversation turns: truncates the history (and the session log) to before
+     * them and restores the file snapshots they took. Returns undefined when nothing is left.
+     */
+    rewindTurns(n: number): Promise<RewindResult | undefined>;
+    startedAt: Date;
+}
+export interface RewindResult {
+    turns: number;
+    restored: string[];
+    deleted: string[];
+    skipped: string[];
+    failed: string[];
+}
+/** PTC is automatic for Luna. This env var is only an emergency/internal kill switch. */
+export declare function lunaPtcAutoEnabled(env: NodeJS.ProcessEnv): boolean;
+export declare function createRuntime(opts: {
+    cwd: string;
+    args: CliArgs;
+    env?: NodeJS.ProcessEnv;
+    provider?: Provider;
+    history?: ChatMessage[];
+    fetch?: typeof fetch;
+    userHome?: string;
+    /** Override langkah agent (mis. githubBot.stepLimit) — menang atas config.maxSteps. */
+    maxSteps?: number | null;
+}): Runtime;

package/dist/slash/copy.d.ts

@@ -0,0 +1 @@
+export declare function osc52(text: string, inTmux: boolean): string;

package/dist/slash/diff.d.ts

@@ -0,0 +1 @@
+export declare function gitDiff(cwd: string, maxLines?: number, bin?: string): Promise<string>;

package/dist/slash/doctor.d.ts

@@ -0,0 +1,18 @@
+export interface DoctorDeps {
+    which: (cmd: string) => boolean | Promise<boolean>;
+    nodeVersion: string;
+    listModels: () => Promise<unknown[]>;
+}
+export declare function doctorText(input: {
+    providers: {
+        id: string;
+        name: string;
+        ready: boolean;
+    }[];
+    mcp: {
+        name: string;
+        status: string;
+        error?: string;
+    }[];
+    activeProvider: string;
+}, deps: DoctorDeps): Promise<string>;

package/dist/slash/export.d.ts

@@ -0,0 +1,2 @@
+import { type ChatMessage } from '../provider';
+export declare function exportMarkdown(messages: ChatMessage[], title: string): string;

package/dist/slash/info.d.ts

@@ -0,0 +1,45 @@
+export interface StatusInput {
+    version: string;
+    modelRef: string;
+    providerLabel: string;
+    mode: string;
+    cwd: string;
+    mcp: {
+        name: string;
+        status: string;
+        error?: string;
+        tools: number;
+    }[];
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cachedInputTokens?: number;
+        cacheWriteTokens?: number;
+    };
+    lastInputTokens: number;
+}
+export declare function statusText(s: StatusInput): string;
+export declare function agentsText(defs: {
+    name: string;
+    description: string;
+    tools?: string[];
+    model?: string;
+}[]): string;
+export declare function skillsText(skills: {
+    name: string;
+    description: string;
+    dir: string;
+}[], commands: {
+    name: string;
+    description?: string;
+}[]): string;
+export declare function sessionText(s: {
+    file: string;
+    started: Date;
+    messages: number;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    modelRef: string;
+}): string;

package/dist/slash/memory.d.ts

@@ -0,0 +1,10 @@
+export declare function instructionFiles(cwd: string, home: string): {
+    path: string;
+    lines: number;
+}[];
+export declare function appendMemory(file: string, text: string): void;
+/** `/memory [global] <teks>` → target file and text; text is empty when nothing follows. */
+export declare function parseMemoryArgs(args: string): {
+    global: boolean;
+    text: string;
+};