@cjhyy/code-shell 0.1.7 → 0.3.0

package/dist/llm/provider-kinds.d.ts

@@ -6,7 +6,7 @@
  * (chat-completion only — embeddings / TTS / image generation are
  * filtered out so they don't show up in the model picker).
  */
-export type ProviderKindName = "openai" | "anthropic" | "deepseek" | "xai" | "mistral" | "groq" | "google" | "openrouter" | "ollama" | "custom";
+export type ProviderKindName = "openai" | "anthropic" | "deepseek" | "zai" | "xai" | "mistral" | "groq" | "google" | "openrouter" | "ollama" | "custom";
 export type ProviderProtocol = "openai-compat" | "anthropic-style" | "gemini" | "ollama";
 export interface ProviderKindMeta {
     label: string;

package/dist/llm/providers/openai.d.ts

@@ -1,15 +1,59 @@
 /**
  * OpenAI GPT provider using openai SDK.
+ *
+ * Serves every OpenAI-compatible endpoint we support (OpenAI, DeepSeek,
+ * OpenRouter, Z.AI, xAI, Mistral, Groq, Gemini-OpenAI-compat, Ollama,
+ * custom). Per-(provider, model) request-shape divergence — token-limit
+ * field name, rejected sampling params, thinking knob, reasoning echo —
+ * is resolved through `capabilitiesFor()`, not hardcoded.
  */
 import type { LLMConfig, LLMResponse } from "../../types.js";
 import type { CreateMessageOptions } from "../types.js";
 import { LLMClientBase } from "../client-base.js";
+interface RunStreamOpts {
+    idleTimeoutMs?: number;
+    requestId?: string;
+    /**
+     * Per-chunk handler — invoked synchronously with the raw chunk for the
+     * provider to do its own parsing. Returns the text delta (or "") for
+     * the watchdog-side text accumulator used in tests.
+     */
+    onChunk?: (chunk: any) => string;
+}
+/**
+ * Consume an async iterable of stream chunks with an idle watchdog.
+ * Returns the accumulated text — either from onChunk return values, or
+ * by extracting choices[0].delta.content from raw chunks (useful in tests
+ * that call runStreamWithWatchdog directly without an onChunk handler).
+ *
+ * The watchdog is active whenever opts.idleTimeoutMs is explicitly provided,
+ * or when STREAM_WATCHDOG_CONFIG.enabled is true. When active, each call to
+ * iterator.next() races against an idle deadline; if the deadline fires first
+ * the function rejects with StreamIdleTimeoutError.
+ */
+export declare function runStreamWithWatchdog<T = any>(stream: AsyncIterable<T>, opts?: RunStreamOpts): Promise<string>;
 export declare class OpenAIClient extends LLMClientBase {
     private _client;
+    private _forceMaxCompletionTokens;
     constructor(config: LLMConfig);
     protected initClient(): void;
     private get client();
+    /**
+     * Resolve the capability descriptor for the current (provider kind, model)
+     * pair. Cached for the lifetime of the client — model never changes
+     * mid-client. `providerKind` defaults to "openai" because legacy LLMConfig
+     * paths (arena, env-derived) don't always populate it; for those, the
+     * built-in rules table treats them as plain OpenAI.
+     */
+    private _capability;
+    private get capability();
     createMessage(options: CreateMessageOptions): Promise<LLMResponse>;
+    /**
+     * Build the request body honoring the model's capability descriptor.
+     * Centralized so both streaming and non-streaming paths agree on the
+     * exact shape.
+     */
+    private buildRequestBody;
     private nonStreamMessage;
     private streamMessage;
     private processChoice;
@@ -17,3 +61,4 @@ export declare class OpenAIClient extends LLMClientBase {
     private convertTools;
     private handleApiError;
 }
+export {};

package/dist/llm/retry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Retry classification — which errors trigger an automatic retry of the
+ * streaming LLM call?
+ *
+ * Stream-idle timeouts are retried — the upstream may have just recovered.
+ * User-initiated aborts (AbortError) are never retried — the user explicitly
+ * asked for the work to stop.
+ *
+ * Other transient errors (5xx, 429, ECONNRESET) are out of scope for this
+ * iteration; add them here as they become observed.
+ */
+export declare function isRetryable(err: unknown): boolean;

package/dist/llm/stream-watchdog.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Stream Idle Watchdog — guarantees an upper bound on the time a streaming
+ * LLM call can spend with no bytes arriving. Without this, a wedged HTTP/2
+ * connection can hang the session indefinitely; the SDK's request timeout
+ * only covers the initial fetch, not the streaming body.
+ *
+ * Disabled by default. Enabled via env CODESHELL_ENABLE_STREAM_WATCHDOG=1.
+ */
+export interface StreamWatchdogOptions {
+    /** Abort the stream when no chunks arrive within this window. */
+    idleTimeoutMs: number;
+    /** Called when the watchdog decides to abort. */
+    onTimeout: () => void;
+    /**
+     * Called at idleTimeoutMs/2 (or warningMs if provided). Logging only —
+     * the watchdog does not abort on warning. The argument is the configured
+     * warning threshold (NOT real-time elapsed) so callers can format the log
+     * without re-deriving it.
+     */
+    onWarning?: (warnThresholdMs: number) => void;
+    /** Override the warning trigger; defaults to idleTimeoutMs / 2. */
+    warningMs?: number;
+}
+export interface StreamWatchdog {
+    /** Re-arm both timers — call after every chunk. */
+    reset(): void;
+    /** Clear all timers permanently — call in finally. */
+    dispose(): void;
+}
+export declare class StreamIdleTimeoutError extends Error {
+    idleMs: number;
+    requestId?: string | undefined;
+    readonly kind = "stream-idle-timeout";
+    constructor(idleMs: number, requestId?: string | undefined);
+}
+export declare function createStreamWatchdog(opts: StreamWatchdogOptions): StreamWatchdog;
+/** Environment-driven defaults. Read once at import time is fine — these never change inside a process. */
+export declare const STREAM_WATCHDOG_CONFIG: {
+    enabled: boolean;
+    idleTimeoutMs: number;
+    retries: number;
+};

package/dist/llm/types.d.ts

@@ -19,6 +19,14 @@ export interface CreateMessageOptions {
      * @default true
      */
     recordUsage?: boolean;
+    /**
+     * DeepSeek V4 thinking-mode switch. "enabled" is the endpoint default;
+     * "disabled" turns reasoning off (faster, cheaper, no `reasoning_content`
+     * on the reply). Ignored by every provider except DeepSeek V4 — the OpenAI
+     * SDK forwards unknown top-level fields verbatim, so it's harmless on
+     * other compatible endpoints.
+     */
+    thinking?: "enabled" | "disabled";
 }
 export interface LLMUsageTracker {
     records: TokenUsage[];

package/dist/logging/logger.d.ts

@@ -1,7 +1,15 @@
 /**
  * Unified file logger for code-shell.
  *
- * Single sink: ~/.code-shell/logs/YYYY-MM-DD.log (JSON Lines).
+ * Sinks (JSON Lines), routed by `cat`:
+ *   ~/.code-shell/logs/ui-ink-YYYY-MM-DD.log
+ *     — UI/ink chatter: stream events, ctx render, ink screen diffs.
+ *   ~/.code-shell/logs/engine-YYYY-MM-DD.log
+ *     — everything else: engine, llm, tool, context, mcp, sandbox, ...
+ *
+ * Routing is by entry `cat`: cat ∈ {ui, ink, render, stream} → ui-ink bucket;
+ * anything else → engine bucket. Run scripts/logs.sh to query both at once
+ * (merge sorted by timestamp, filter by sid, etc).
  *
  * Level defaults:
  *   - Local dev (CODE_SHELL_DEV=1, or running from src/, or --debug)   → "debug"
@@ -9,13 +17,27 @@
  *   - CODE_SHELL_LOG_LEVEL overrides everything.
  *
  * Category filter (--debug=mcp,api or CODE_SHELL_DEBUG=mcp,api):
- *   When set, only logs whose `cat` matches are written.
+ *   When set, only debug logs whose `cat` matches are written.
  *
  * Disable entirely: CODE_SHELL_LOG=0
  */
 export type LogLevel = "debug" | "info" | "warn" | "error";
 export declare function setCurrentSid(sid: string): void;
 export declare function getCurrentSid(): string;
+/**
+ * Run `fn` inside an ALS scope tagged with `sid`. All log lines emitted
+ * synchronously or via `await` inside `fn` resolve `getCurrentSid()` to
+ * this `sid` — concurrent Engine.run invocations no longer race on a
+ * module global.
+ */
+export declare function runWithSid<T>(sid: string, fn: () => T | Promise<T>): T | Promise<T>;
+/**
+ * Bind `sid` to the *current* async context without needing a callback.
+ * The binding lasts until the current async stack unwinds; concurrent
+ * sibling async chains keep their own bindings. Engine.run uses this so
+ * we don't have to indent the entire (long) method body into a callback.
+ */
+export declare function enterSid(sid: string): void;
 export declare function getInMemoryErrors(): ReadonlyArray<{
     msg: string;
     t: string;

package/dist/logging/session-recorder.d.ts

@@ -1,9 +1,16 @@
 /**
  * Per-session verbose recorder for local-dev runs.
  *
- * Writes a JSON-lines trace to <repo>/log/<YYYY-MM-DD>/session-<sid>.jsonl
- * containing every step: user input, system prompt, each LLM request+response
- * (full bodies), each tool call's args and result, and engine decision events.
+ * Layout (per day, split by bucket):
+ *   <repo>/log/<YYYY-MM-DD>/engine/session-<sid>.jsonl
+ *     — unified timeline: LLM, tools, session events, AND UI events
+ *       (UI events are dual-written so this file is the full story.)
+ *   <repo>/log/<YYYY-MM-DD>/ui/session-<sid>.jsonl
+ *     — UI-only events (stream events received, ctx renders, chatStore
+ *       mutations). Open when chasing a display bug.
+ *
+ * Same sid → same filename in both folders. Diff/merge by sid to align
+ * "what the model said" with "what the UI did about it."
  *
  * Why a separate sink from logger.ts?
  *   - logger.ts is the terse process-wide log (~/.code-shell/logs/) and stays
@@ -69,6 +76,12 @@ export declare function recordToolResult(sid: string, result: {
     error?: string;
 }): void;
 export declare function recordEvent(sid: string, name: string, data?: Record<string, unknown>): void;
+/**
+ * Record a UI-side event. Goes into both engine.jsonl (unified timeline) and
+ * ui.jsonl (focused view). Use from the UI when chasing display bugs — pass
+ * the current sessionId.
+ */
+export declare function recordUIEvent(sid: string | undefined, name: string, data?: Record<string, unknown>): void;
 export declare function recordSessionEnd(sid: string, info: {
     reason?: string;
     turns?: number;

package/dist/manager-4XKLZHKE.js

@@ -0,0 +1 @@
+export{c as SettingsManager}from'./chunk-FZXY554D.js';import'./chunk-3QP5BQ3L.js';

package/dist/mcp-manager-3JGHEJO3.js

@@ -0,0 +1 @@
+export{a as MCPManager}from'./chunk-D3TVASD2.js';import'./chunk-DI26OUIU.js';import'./chunk-3QP5BQ3L.js';

package/dist/model-fetcher-X5W5EASG.js

@@ -0,0 +1 @@
+export{b as fetchModelList}from'./chunk-2OD6VR4N.js';import'./chunk-P6JSTIFM.js';import'./chunk-3QP5BQ3L.js';

package/dist/openai-OQ6LLN5J.js

@@ -0,0 +1 @@
+export{b as OpenAIClient,a as runStreamWithWatchdog}from'./chunk-SV7H4FKT.js';import'./chunk-O5HFCH2U.js';import'./chunk-OWBYLMDD.js';import'./chunk-FU7AHZNN.js';import'./chunk-DI26OUIU.js';import'./chunk-3QP5BQ3L.js';

package/dist/{openrouter-models-AM6M52D6.js → openrouter-models-ZT4R2AE3.js}

@@ -1 +1 @@
-export{d as findOpenRouterModel,c as getOpenRouterModels,b as getOpenRouterSnapshot,e as listOpenRouterModelsByVendor,a as setOpenRouterSnapshot}from'./chunk-NVAZJ5XS.js';import'./chunk-3QP5BQ3L.js';
+export{d as findOpenRouterModel,c as getOpenRouterModels,b as getOpenRouterSnapshot,e as listOpenRouterModelsByVendor,a as setOpenRouterSnapshot}from'./chunk-GKAQH2DG.js';import'./chunk-3QP5BQ3L.js';

package/dist/openrouter-sync-ARMVWY7S.js

@@ -0,0 +1 @@
+export{a as syncOpenRouterCatalog}from'./chunk-AFMP73YP.js';export{b as getOpenRouterSnapshot}from'./chunk-GKAQH2DG.js';import'./chunk-3QP5BQ3L.js';

package/dist/plugin-handler-GJISMH5Q.js

@@ -0,0 +1,11 @@
+import {g,f,e,d,i}from'./chunk-SKIX2M5Z.js';import {h,a,b}from'./chunk-3QP5BQ3L.js';import {existsSync,readFileSync,mkdirSync,writeFileSync,rmSync,readdirSync,statSync,cpSync,mkdtempSync}from'fs';import {join,dirname,isAbsolute,resolve}from'path';import {homedir,tmpdir}from'os';import {spawn}from'child_process';h();h();function H(e){let r=e.trim();if(r==="")return null;if((r.startsWith("/")||/^[a-zA-Z]:[\\/]/.test(r))&&r.endsWith(".git"))return {source:"git",url:r};if(r.match(/^[a-zA-Z0-9._-]+@[^:\s]+:[^\s]+$/))return {source:"git",url:r};if(r.startsWith("https://")||r.startsWith("http://")){let i;try{i=new URL(r);}catch{return null}return i.hostname==="github.com"||i.hostname==="www.github.com"?i.pathname.match(/^\/([^/]+\/[^/]+?)(\/|\.git|$)/)?{source:"git",url:r.endsWith(".git")?r:`${r}.git`}:null:r.endsWith(".git")?{source:"git",url:r}:null}let n=r.match(/^([A-Za-z0-9][A-Za-z0-9._-]*)\/([A-Za-z0-9._-]+?)(\.git)?$/);if(n){let i=n[1],s=n[2];return {source:"github",repo:`${i}/${s}`}}return null}a(H,"parseMarketplaceInput");function q(e){if(e.source==="github"){let i=e.repo.split("/");return i[i.length-1].toLowerCase()}let t=e.url.replace(/\.git$/,"").split(/[/:]/).filter(Boolean);return (t[t.length-1]??"marketplace").toLowerCase()}a(q,"deriveMarketplaceName");h();h();async function x(e,r,t=6e4){return new Promise(n=>{let i=spawn("git",e,{cwd:r,stdio:["ignore","pipe","pipe"]}),s="",o="";i.stdout.on("data",l=>s+=l.toString()),i.stderr.on("data",l=>o+=l.toString());let a=setTimeout(()=>{i.kill("SIGKILL"),n({ok:false,error:`git ${e.join(" ")} timed out after ${t}ms`});},t);i.on("close",l=>{clearTimeout(a),n(l===0?{ok:true,stdout:s.trim()}:{ok:false,error:`git ${e.join(" ")} exited ${l}: ${o.trim()||"unknown error"}`});}),i.on("error",l=>{clearTimeout(a),n({ok:false,error:`git ${e.join(" ")} failed: ${l.message}`});});})}a(x,"runGit");async function $(e,r,t){let n=["clone","--depth","1"];return t?.ref&&n.push("--branch",t.ref),n.push("--",e,r),x(n)}a($,"gitClone");async function C(e){return x(["rev-parse","HEAD"],e)}a(C,"gitRevParseHead");async function z(e,r){let t=["fetch","--depth","1","origin"];r&&t.push(r);let n=await x(t,e);return n.ok?x(["reset","--hard",r?`origin/${r}`:"FETCH_HEAD"],e):n}a(z,"gitFetchAndReset");function j(e){return `https://github.com/${e}.git`}a(j,"githubRepoToCloneUrl");h();function Se(){return process.env.HOME??homedir()}a(Se,"userHome");function V(){return join(Se(),".code-shell","plugins","known_marketplaces.json")}a(V,"knownMarketplacesPath");function m(){let e=V();if(!existsSync(e))return {};try{let r=JSON.parse(readFileSync(e,"utf-8"));if(r&&typeof r=="object"&&!Array.isArray(r))return r}catch{}return {}}a(m,"readKnownMarketplaces");function J(e){let r=V();mkdirSync(dirname(r),{recursive:true}),writeFileSync(r,JSON.stringify(e,null,2)+`
+`,"utf-8");}a(J,"writeKnownMarketplaces");function B(e,r){let t=m();t[e]=r,J(t);}a(B,"upsertKnownMarketplace");function N(e){let r=m();return e in r?(delete r[e],J(r),true):false}a(N,"removeKnownMarketplace");h();function S(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)}a(S,"isObject");function Me(e,r){if(typeof e=="string")return e.length===0?{ok:false,error:`${r}: source string is empty`}:{ok:true,value:e};if(!S(e))return {ok:false,error:`${r}: source must be a string or object`};let t=e.source;return t==="git"?typeof e.url!="string"||!e.url?{ok:false,error:`${r}: git source requires url`}:{ok:true,value:{source:"git",url:e.url,ref:typeof e.ref=="string"?e.ref:void 0,sha:typeof e.sha=="string"?e.sha:void 0}}:t==="github"?typeof e.repo!="string"||!e.repo.includes("/")?{ok:false,error:`${r}: github source requires repo "owner/name"`}:{ok:true,value:{source:"github",repo:e.repo,ref:typeof e.ref=="string"?e.ref:void 0,sha:typeof e.sha=="string"?e.sha:void 0}}:t==="git-subdir"?typeof e.url!="string"||!e.url?{ok:false,error:`${r}: git-subdir source requires url`}:typeof e.path!="string"||!e.path?{ok:false,error:`${r}: git-subdir source requires path`}:{ok:true,value:{source:"git-subdir",url:e.url,path:e.path,ref:typeof e.ref=="string"?e.ref:void 0,sha:typeof e.sha=="string"?e.sha:void 0}}:{ok:false,error:`${r}: unsupported source type "${String(t)}" (MVP supports git, github, git-subdir, or a string path)`}}a(Me,"validatePluginEntrySource");function be(e,r){let t=`plugins[${r}]`;if(!S(e))return {ok:false,error:`${t}: must be an object`};if(typeof e.name!="string"||!e.name)return {ok:false,error:`${t}: name is required`};if(e.source===void 0)return {ok:false,error:`${t}: source is required`};let n=Me(e.source,`${t}.source`);if(!n.ok)return n;let i;if(e.author!==void 0){if(!S(e.author)||typeof e.author.name!="string")return {ok:false,error:`${t}.author: must be an object with name`};i={name:e.author.name,email:typeof e.author.email=="string"?e.author.email:void 0};}return {ok:true,value:{name:e.name,description:typeof e.description=="string"?e.description:void 0,author:i,category:typeof e.category=="string"?e.category:void 0,source:n.value,homepage:typeof e.homepage=="string"?e.homepage:void 0}}}a(be,"validatePluginEntry");function L(e){if(!S(e))return {ok:false,error:"marketplace.json: not an object"};if(typeof e.name!="string"||!e.name)return {ok:false,error:"marketplace.json: name is required"};if(!S(e.owner)||typeof e.owner.name!="string")return {ok:false,error:"marketplace.json: owner.name is required"};if(!Array.isArray(e.plugins))return {ok:false,error:"marketplace.json: plugins must be an array"};let r=[];for(let t=0;t<e.plugins.length;t++){let n=be(e.plugins[t],t);if(!n.ok)return n;r.push(n.value);}return {ok:true,value:{name:e.name,description:typeof e.description=="string"?e.description:void 0,owner:{name:e.owner.name,email:typeof e.owner.email=="string"?e.owner.email:void 0},plugins:r}}}a(L,"validateMarketplace");function Re(){return process.env.HOME??homedir()}a(Re,"userHome");function W(){return join(Re(),".code-shell","plugins","marketplaces")}a(W,"marketplacesRoot");function D(e){return join(W(),e)}a(D,"marketplaceDir");function Z(e){return join(D(e),".claude-plugin","marketplace.json")}a(Z,"marketplaceJsonPath");function xe(e){return e.source==="github"?j(e.repo):e.url}a(xe,"sourceToCloneUrl");async function Y(e,r){let t=D(e),i=m()[e];if(i&&JSON.stringify(i.source)===JSON.stringify(r)&&existsSync(t)){let g=(r.source==="git",void 0);await z(t,g);}else {existsSync(t)&&rmSync(t,{recursive:true,force:true}),mkdirSync(W(),{recursive:true});let g=await $(xe(r),t);if(!g.ok)return {ok:false,error:g.error}}let o=Z(e);if(!existsSync(o))return rmSync(t,{recursive:true,force:true}),{ok:false,error:`Marketplace ${e}: .claude-plugin/marketplace.json not found in the cloned repository.`};let a;try{a=JSON.parse(readFileSync(o,"utf-8"));}catch(g){return rmSync(t,{recursive:true,force:true}),{ok:false,error:`Marketplace ${e}: failed to parse marketplace.json: ${g.message}`}}let l=L(a);if(!l.ok)return rmSync(t,{recursive:true,force:true}),{ok:false,error:`Marketplace ${e}: ${l.error}`};let d={source:r,installLocation:t,lastUpdated:new Date().toISOString()};return B(e,d),{ok:true,name:e,marketplace:l.value,replaced:!!i}}a(Y,"addMarketplace");function Q(e){let r=N(e),t=D(e);return existsSync(t)&&rmSync(t,{recursive:true,force:true}),r}a(Q,"removeMarketplace");function F(e){if(!m()[e])return null;let t=Z(e);if(!existsSync(t))return null;let n;try{n=JSON.parse(readFileSync(t,"utf-8"));}catch{return null}let i=L(n);return i.ok?i.value:null}a(F,"loadMarketplace");function X(){let e=m(),r=[];for(let[t,n]of Object.entries(e)){let i=F(t);r.push({name:t,source:n.source,installLocation:n.installLocation,lastUpdated:n.lastUpdated,pluginCount:i?i.plugins.length:-1});}return r.sort((t,n)=>t.name.localeCompare(n.name))}a(X,"listMarketplaces");h();h();var K="CLAUDE_PLUGIN_ROOT",te="CODESHELL_PLUGIN_ROOT",Ie=8192;function Oe(e){let r=Math.min(e.length,Ie);for(let t=0;t<r;t++)if(e[t]===0)return  true;return  false}a(Oe,"isLikelyBinary");function ne(e,r){let t;try{t=readdirSync(e,{withFileTypes:!0});}catch{return}for(let n of t){let i=join(e,n.name);if(n.isSymbolicLink())continue;if(n.isDirectory()){if(n.name===".git")continue;ne(i,r);continue}if(!n.isFile())continue;let s;try{s=readFileSync(i);}catch{continue}if(r.filesScanned+=1,Oe(s))continue;let o=s.toString("utf8");if(!o.includes(K))continue;let a=o.split(K).join(te);try{writeFileSync(i,a,"utf8"),r.filesRewritten+=1,r.rewrittenPaths.push(i);}catch{}}}a(ne,"walkAndRewrite");function ie(e){let r={filesScanned:0,filesRewritten:0,rewrittenPaths:[]},t=false;try{t=statSync(e).isDirectory();}catch{t=false;}if(!t)return r;ne(e,r);let n={rewrittenAt:new Date().toISOString(),from:K,to:te,filesScanned:r.filesScanned,filesRewritten:r.filesRewritten,note:"codeshell rewrote plugin files at install time so ${CLAUDE_PLUGIN_ROOT} placeholders use codeshell's native env var. Upstream plugin sources are unchanged; only this local copy was modified."};try{writeFileSync(join(e,".code-shell-installed.json"),JSON.stringify(n,null,2)+`
+`,"utf8");}catch{}return r}a(ie,"rewritePluginVars");function Ke(){return process.env.HOME??homedir()}a(Ke,"userHome");function se(){return join(Ke(),".code-shell","plugins","cache")}a(se,"pluginCacheRoot");function E(e,r,t){return join(se(),e,r,t)}a(E,"pluginCacheDir");async function _e(e,r,t){let n=isAbsolute(r)?r:resolve(e,r);return existsSync(n)?(mkdirSync(dirname(t),{recursive:true}),existsSync(t)&&rmSync(t,{recursive:true,force:true}),cpSync(n,t,{recursive:true}),{ok:true,sha:void 0}):{ok:false,error:`plugin source path "${r}" not found in marketplace`}}a(_e,"materializePath");async function Ge(e,r,t){mkdirSync(dirname(t),{recursive:true}),existsSync(t)&&rmSync(t,{recursive:true,force:true});let n=await $(e,t,r?{ref:r}:void 0);if(!n.ok)return {ok:false,error:n.error};let i=await C(t);return i.ok?{ok:true,sha:i.stdout}:{ok:false,error:i.error}}a(Ge,"materializeGit");async function He(e,r,t,n){let i=mkdtempSync(join(tmpdir(),"plugin-clone-"));try{let s=await $(e,i+"/repo",t?{ref:t}:void 0);if(!s.ok)return {ok:!1,error:s.error};let o=await C(i+"/repo");if(!o.ok)return {ok:!1,error:o.error};let a=join(i,"repo",r);return existsSync(a)?(mkdirSync(dirname(n),{recursive:!0}),existsSync(n)&&rmSync(n,{recursive:!0,force:!0}),cpSync(a,n,{recursive:!0}),{ok:!0,sha:o.stdout}):{ok:!1,error:`git-subdir path "${r}" not found in cloned repository`}}finally{rmSync(i,{recursive:true,force:true});}}a(He,"materializeGitSubdir");function oe(e){return e?e.slice(0,12):"unknown"}a(oe,"shortSha");async function qe(e,r,t,n){let i=E(t,n,"_pending_");if(typeof e=="string"){let s=await _e(r,e,i);if(!s.ok)return s;let o=E(t,n,"local");return existsSync(o)&&rmSync(o,{recursive:true,force:true}),mkdirSync(dirname(o),{recursive:true}),cpSync(i,o,{recursive:true}),rmSync(i,{recursive:true,force:true}),{ok:true,cacheDir:o,version:"local",sha:void 0}}if(e.source==="git"||e.source==="github"){let s=e.source==="github"?j(e.repo):e.url,o=await Ge(s,e.ref,i);if(!o.ok)return existsSync(i)&&rmSync(i,{recursive:true,force:true}),o;let a=oe(o.sha),l=E(t,n,a);return existsSync(l)&&rmSync(l,{recursive:true,force:true}),mkdirSync(dirname(l),{recursive:true}),cpSync(i,l,{recursive:true}),rmSync(i,{recursive:true,force:true}),{ok:true,cacheDir:l,version:a,sha:o.sha}}if(e.source==="git-subdir"){let s=await He(e.url,e.path,e.ref,i);if(!s.ok)return existsSync(i)&&rmSync(i,{recursive:true,force:true}),s;let o=oe(s.sha),a=E(t,n,o);return existsSync(a)&&rmSync(a,{recursive:true,force:true}),mkdirSync(dirname(a),{recursive:true}),cpSync(i,a,{recursive:true}),rmSync(i,{recursive:true,force:true}),{ok:true,cacheDir:a,version:o,sha:s.sha}}return {ok:false,error:`unsupported source type "${e.source}"`}}a(qe,"materialize");async function ue(e$1,r){let n=m()[r];if(!n)return {ok:false,error:`marketplace "${r}" not found. Run /plugin marketplace add first.`};let i=F(r);if(!i)return {ok:false,error:`marketplace "${r}" is registered but its manifest could not be loaded.`};let s=i.plugins.find(fe=>fe.name===e$1);if(!s)return {ok:false,error:`plugin "${e$1}" not found in marketplace "${r}".`};let o=await qe(s.source,n.installLocation,r,e$1);if(!o.ok)return o;let a=ie(o.cacheDir),l=g(e$1,r);f(l);let d=new Date().toISOString(),g$1={scope:"user",installPath:o.cacheDir,version:o.version,installedAt:d,lastUpdated:d,...o.sha?{gitCommitSha:o.sha}:{}};return e(l,g$1),{ok:true,entry:g$1,freshlyCloned:true,varRewrite:{filesScanned:a.filesScanned,filesRewritten:a.filesRewritten}}}a(ue,"installPlugin");function ae(e,r){let t=g(e,r),i=d().plugins[t],s=false;if(i){for(let l of i)l.installPath&&existsSync(l.installPath)&&(rmSync(l.installPath,{recursive:true,force:true}),s=true);let a=join(se(),r,e);try{b("fs").rmdirSync(a);}catch{}}let o=f(t);return {ok:o||s,removedFromManifest:o,removedFromDisk:s}}a(ae,"uninstallPlugin");function le(){let e=d(),r=[];for(let[t,n]of Object.entries(e.plugins))for(let i of n)r.push({key:t,entry:i});return r.sort((t,n)=>t.key.localeCompare(n.key)),r}a(le,"listInstalled");var _=["Usage:","  /plugin marketplace add <git-url-or-owner/repo>","  /plugin marketplace remove <name>","  /plugin marketplace list","  /plugin install <plugin>@<marketplace>","  /plugin uninstall <plugin>@<marketplace>","  /plugin list"].join(`
+`);function ce(e){let r=e.lastIndexOf("@");return r<=0||r===e.length-1?null:{plugin:e.slice(0,r),marketplace:e.slice(r+1)}}a(ce,"splitInstallKey");async function Ar(e){let r=e.trim().split(/\s+/).filter(Boolean);if(r.length===0)return _;let t=r[0];if(t==="marketplace"){let n=r[1];if(n==="add"){let i=r.slice(2).join(" ").trim();if(!i)return "Usage: /plugin marketplace add <git-url-or-owner/repo>";let s=H(i);if(!s)return `Cannot parse "${i}" as a marketplace source.
+Supported forms: owner/repo, https://...git, git@host:owner/repo[.git], /abs/path/to/repo.git`;let o=q(s),a=await Y(o,s);if(!a.ok)return `Failed to add marketplace "${o}": ${a.error}`;let l=[a.replaced?`Refreshed marketplace "${a.name}"`:`Added marketplace "${a.name}"`,`  plugins available: ${a.marketplace.plugins.length}`];for(let d of a.marketplace.plugins.slice(0,10))l.push(`    - ${d.name}${d.description?`: ${d.description}`:""}`);return a.marketplace.plugins.length>10&&l.push(`    ... (${a.marketplace.plugins.length-10} more)`),l.join(`
+`)}if(n==="remove"){let i$1=r[2];if(!i$1)return "Usage: /plugin marketplace remove <name>";let s=Q(i$1);return i(),s?`Removed marketplace "${i$1}"`:`Marketplace "${i$1}" not found`}if(n==="list"||n===void 0){let i=X();if(i.length===0)return "No marketplaces. Use /plugin marketplace add <url>.";let s=[`Marketplaces (${i.length}):`];for(let o of i){let a=o.source.source==="github"?`github:${o.source.repo}`:o.source.url,l=o.pluginCount>=0?`${o.pluginCount} plugins`:"manifest unreadable";s.push(`  ${o.name}  (${a})  \u2014 ${l}`);}return s.join(`
+`)}return `Unknown subcommand "marketplace ${n}".
+${_}`}if(t==="install"){let n=r[1];if(!n)return "Usage: /plugin install <plugin>@<marketplace>";let i$1=ce(n);if(!i$1)return `Expected <plugin>@<marketplace>, got "${n}"`;let s=await ue(i$1.plugin,i$1.marketplace);if(!s.ok)return `Failed to install ${n}: ${s.error}`;i();let o=[`Installed ${n}`,`  version: ${s.entry.version}`,`  path:    ${s.entry.installPath}`];return s.varRewrite.filesRewritten>0&&o.push(`  rewrote: ${s.varRewrite.filesRewritten} file(s) \u2014 \${CLAUDE_PLUGIN_ROOT} \u2192 \${CODESHELL_PLUGIN_ROOT}`),o.join(`
+`)}if(t==="uninstall"){let n=r[1];if(!n)return "Usage: /plugin uninstall <plugin>@<marketplace>";let i$1=ce(n);if(!i$1)return `Expected <plugin>@<marketplace>, got "${n}"`;let s=ae(i$1.plugin,i$1.marketplace);if(i(),!s.removedFromManifest&&!s.removedFromDisk)return `${n} was not installed`;let o=[];return s.removedFromManifest&&o.push("manifest entry"),s.removedFromDisk&&o.push("cache dir"),`Uninstalled ${n} (removed ${o.join(" + ")})`}if(t==="list"){let n=le();if(n.length===0)return "No plugins installed.";let i=[`Installed plugins (${n.length}):`];for(let{key:s,entry:o}of n)i.push(`  ${s}  v${o.version}  ${o.installPath}`);return i.join(`
+`)}return `Unknown subcommand "${t}".
+${_}`}a(Ar,"runPluginCommand");export{Ar as runPluginCommand};

package/dist/plugins/gitOps.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Minimal `git` subprocess wrappers used by the plugin marketplace. Each
+ * function returns a discriminated union so callers can produce useful
+ * error messages without try/catching. Mirrors Claude Code's
+ * utils/plugins/marketplaceManager.ts:loadAndCacheMarketplace at the
+ * subset we need for the MVP.
+ */
+export type GitResult = {
+    ok: true;
+    stdout: string;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function gitClone(url: string, destDir: string, options?: {
+    ref?: string;
+}): Promise<GitResult>;
+export declare function gitRevParseHead(repoDir: string): Promise<GitResult>;
+export declare function gitFetchAndReset(repoDir: string, ref?: string): Promise<GitResult>;
+/**
+ * Github source helper: convert "owner/repo" to an https clone URL.
+ */
+export declare function githubRepoToCloneUrl(repo: string): string;

package/dist/plugins/installedPlugins.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Read/write ~/.code-shell/plugins/installed_plugins.json (V2 format).
+ * Byte-compatible with Claude Code's analogous file.
+ */
+import type { InstalledPluginsV2, PluginInstallEntry } from "./types.js";
+export declare function installedPluginsPath(): string;
+export declare function readInstalledPlugins(): InstalledPluginsV2;
+export declare function writeInstalledPlugins(data: InstalledPluginsV2): void;
+/**
+ * Append an install entry for `<plugin>@<marketplace>`. Multiple entries
+ * for the same key are allowed (different scopes); MVP only writes scope:"user".
+ */
+export declare function appendInstallEntry(key: string, entry: PluginInstallEntry): void;
+export declare function removeInstallEntries(key: string): boolean;
+export declare function pluginInstallKey(plugin: string, marketplace: string): string;

package/dist/plugins/knownMarketplaces.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Read/write ~/.code-shell/plugins/known_marketplaces.json.
+ * File format is byte-compatible with Claude Code's analogous file.
+ */
+import type { KnownMarketplaces, KnownMarketplace } from "./types.js";
+export declare function knownMarketplacesPath(): string;
+export declare function readKnownMarketplaces(): KnownMarketplaces;
+export declare function writeKnownMarketplaces(data: KnownMarketplaces): void;
+export declare function upsertKnownMarketplace(name: string, entry: KnownMarketplace): void;
+export declare function removeKnownMarketplace(name: string): boolean;

package/dist/plugins/loadPluginHooks.d.ts

@@ -0,0 +1,52 @@
+/**
+ * loadPluginHooks — scan every installed plugin's hooks/hooks.json and
+ * register the command-type hooks with the engine's HookRegistry.
+ *
+ * Plugin hooks.json schema (Claude Code-compatible):
+ *
+ *   {
+ *     "hooks": {
+ *       "<EventName>": [
+ *         {
+ *           "matcher": "<regex>",      // optional; semantics depend on event
+ *           "hooks": [
+ *             {
+ *               "type": "command",
+ *               "command": "...",      // ${CODESHELL_PLUGIN_ROOT} placeholder
+ *               "async": false,        // currently ignored (always sync await)
+ *               "timeout_ms": 60000    // optional override
+ *             }
+ *           ]
+ *         }
+ *       ]
+ *     }
+ *   }
+ *
+ * Event-name mapping (CC PascalCase → codeshell snake_case):
+ *   SessionStart       → on_session_start
+ *   UserPromptSubmit   → user_prompt_submit
+ *   PreToolUse         → pre_tool_use
+ *   PostToolUse        → post_tool_use
+ *   PreCompact         → pre_compact
+ *   Notification       → notification
+ *   Stop               → on_session_end
+ *   SubagentStop       → (skipped — codeshell sub-agents don't surface this event)
+ *
+ * matcher semantics:
+ *   SessionStart    — matches against ctx.data.source ("startup"|"resume"|"clear"|"compact")
+ *   PreToolUse /
+ *   PostToolUse     — matches against ctx.data.toolName
+ *   other events    — matcher is currently ignored (the CC spec doesn't
+ *                     define matcher semantics for them either)
+ *
+ * Errors are swallowed per-plugin: a malformed hooks.json from one plugin
+ * must not block other plugins from loading.
+ */
+import type { HookRegistry } from "../hooks/registry.js";
+/**
+ * Walk installed plugins and register their command hooks. Safe to call
+ * multiple times — the caller is responsible for not double-registering
+ * (HookRegistry has no de-dup; the engine constructor calls this exactly
+ * once after creating the registry).
+ */
+export declare function loadPluginHooks(registry: HookRegistry): void;

package/dist/plugins/marketplaceManager.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Marketplace lifecycle: add (clone + validate + persist), remove
+ * (delete from disk + manifest), list, load (read marketplace.json on
+ * demand). Mirrors Claude Code's utils/plugins/marketplaceManager.ts
+ * at the MVP subset (github + git sources only, no auto-update,
+ * no policy blocking, no GCS mirror).
+ */
+import type { MarketplaceSource, PluginMarketplace } from "./types.js";
+export declare function marketplacesRoot(): string;
+export declare function marketplaceDir(name: string): string;
+export type AddMarketplaceResult = {
+    ok: true;
+    name: string;
+    marketplace: PluginMarketplace;
+    replaced: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Adds a marketplace by cloning it (or refreshing if already present
+ * with the same source), validating its marketplace.json, and writing
+ * an entry into known_marketplaces.json.
+ */
+export declare function addMarketplace(name: string, source: MarketplaceSource): Promise<AddMarketplaceResult>;
+/**
+ * Removes a marketplace: deletes the cached clone and the manifest entry.
+ * Returns whether anything was actually removed.
+ */
+export declare function removeMarketplace(name: string): boolean;
+/**
+ * Loads a previously-added marketplace's manifest from disk. Returns null
+ * if the marketplace is unknown or the manifest is gone (caller can
+ * report to user).
+ */
+export declare function loadMarketplace(name: string): PluginMarketplace | null;
+export interface ListedMarketplace {
+    name: string;
+    source: MarketplaceSource;
+    installLocation: string;
+    lastUpdated: string;
+    pluginCount: number;
+}
+/**
+ * Lists all known marketplaces with a quick plugin count read from each
+ * cached manifest. Marketplaces whose manifest is missing or invalid
+ * show pluginCount: -1 so the caller can flag them.
+ */
+export declare function listMarketplaces(): ListedMarketplace[];

package/dist/plugins/parseMarketplaceInput.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Parse a user-typed marketplace identifier into a MarketplaceSource.
+ * MVP subset of Claude Code's utils/plugins/parseMarketplaceInput.ts —
+ * local absolute paths, github shorthand, https git URLs, and ssh git URLs.
+ */
+import type { MarketplaceSource } from "./types.js";
+/**
+ * Returns the parsed source, or null when the input does not match any
+ * supported pattern. Callers should show a usage hint on null.
+ */
+export declare function parseMarketplaceInput(input: string): MarketplaceSource | null;
+/**
+ * Derive a stable marketplace name from a source. Used as the filesystem
+ * directory and the key in known_marketplaces.json.
+ */
+export declare function deriveMarketplaceName(source: MarketplaceSource): string;

package/dist/plugins/pluginCommandHook.d.ts

@@ -0,0 +1,54 @@
+/**
+ * pluginCommandHook — execute a plugin's command-type hook as a child
+ * process and translate its stdout into a HookResult.
+ *
+ * This is the plugin-side analogue of `src/hooks/shell-runner.ts`. The two
+ * runners are intentionally separate because they speak different protocols:
+ *
+ *   src/hooks/shell-runner.ts     codeshell-native: stdout is a HookResult
+ *                                 JSON envelope ({ messages, decision, ... }).
+ *                                 Used by user-authored settings.hooks.
+ *
+ *   this file                     CC plugin protocol: stdout is one of
+ *                                 - { hookSpecificOutput: { hookEventName, additionalContext } }
+ *                                 - { additional_context: "..." }            (Cursor)
+ *                                 - { additionalContext: "..." }             (SDK)
+ *                                 We normalize all three into HookResult.messages
+ *                                 so downstream hook plumbing (inject.ts) is
+ *                                 untouched.
+ *
+ * env contract:
+ *   CODESHELL_PLUGIN_ROOT   — set to installPath. Plugin command strings
+ *                             reference this via ${CODESHELL_PLUGIN_ROOT}
+ *                             (varRewrite.ts rewrites CC's CLAUDE_PLUGIN_ROOT
+ *                             to this name at install time).
+ *   CODESHELL_HOOK_EVENT    — the codeshell-side event name (snake_case)
+ *
+ * We deliberately do NOT set CLAUDE_PLUGIN_ROOT here. Plugin scripts that
+ * branch on which host they detect (e.g. superpowers' session-start checks
+ * `[ -n "${CLAUDE_PLUGIN_ROOT:-}" ]`) get rewritten by varRewrite.ts at
+ * install time, so the branch they take after rewrite is the codeshell
+ * branch — not the CC one.
+ */
+import type { HookContext, HookResult } from "../hooks/events.js";
+export interface PluginCommandHookSpec {
+    /** Shell command line, with ${CODESHELL_PLUGIN_ROOT} placeholder allowed. */
+    command: string;
+    /** Plugin install path; exported as CODESHELL_PLUGIN_ROOT for the child. */
+    installPath: string;
+    /** Plugin install key (`name@marketplace`), used for log lines. */
+    pluginKey: string;
+    /** Per-hook override; falls back to DEFAULT_TIMEOUT_MS. */
+    timeoutMs?: number;
+}
+/**
+ * Run one plugin hook command. Returns an empty HookResult on any failure
+ * (spawn error, timeout, non-zero exit, unparseable stdout) so the hook
+ * chain keeps moving — a misbehaving plugin must not wedge the engine.
+ *
+ * Stdin carries the same envelope shape the codeshell-native shell-runner
+ * uses (eventName + data) so plugin authors who want richer context can
+ * read it; CC plugins typically ignore stdin and emit context derived from
+ * their own state (e.g. reading a SKILL.md off disk via PLUGIN_ROOT).
+ */
+export declare function runPluginCommandHook(spec: PluginCommandHookSpec, ctx: HookContext): Promise<HookResult>;

package/dist/plugins/pluginCommandsLoader.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Discover plugin-provided slash commands. For each installed plugin,
+ * walks <installPath>/commands/*.md and returns one PluginCommand per
+ * markdown file. Mirrors Claude Code's loadPluginCommands.ts at the
+ * MVP subset (single-level commands directory, no nested subcommands,
+ * no inline-via-plugin.json commands).
+ */
+export interface PluginCommand {
+    /** Namespaced name, e.g. "superpowers:brainstorming" */
+    name: string;
+    /** Plain command (without plugin prefix), e.g. "brainstorming" */
+    commandName: string;
+    /** Plugin id (without @marketplace), e.g. "superpowers" */
+    pluginName: string;
+    /** Frontmatter description, coerced. May be empty. */
+    description: string;
+    /** Frontmatter "argument-hint" if present. */
+    argumentHint?: string;
+    /** Body of the .md (frontmatter stripped). */
+    body: string;
+    /** Absolute path to the .md file. */
+    filePath: string;
+}
+export declare function scanPluginCommands(): PluginCommand[];
+export declare function invalidatePluginCommandsCache(): void;

package/dist/plugins/pluginInstaller.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Install / uninstall plugins from a known marketplace. Mirrors Claude
+ * Code's installResolvedPlugin pattern at the MVP subset: four entry
+ * source types (path / git / github / git-subdir), no dependencies, no
+ * sparse-checkout, no npm/pip.
+ */
+import type { PluginInstallEntry } from "./types.js";
+export interface VarRewriteReport {
+    filesScanned: number;
+    filesRewritten: number;
+}
+export type InstallResult = {
+    ok: true;
+    entry: PluginInstallEntry;
+    freshlyCloned: boolean;
+    varRewrite: VarRewriteReport;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Install a plugin from a previously-added marketplace into the user
+ * cache. Idempotent within a process: re-installing replaces the
+ * cached files and updates the manifest entry.
+ */
+export declare function installPlugin(pluginName: string, marketplaceName: string): Promise<InstallResult>;
+export interface UninstallResult {
+    ok: boolean;
+    removedFromManifest: boolean;
+    removedFromDisk: boolean;
+}
+export declare function uninstallPlugin(pluginName: string, marketplaceName: string): UninstallResult;
+export declare function listInstalled(): {
+    key: string;
+    entry: PluginInstallEntry;
+}[];

package/dist/plugins/schemas.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Lightweight validators for plugin marketplace JSON shapes. Returns
+ * { ok, value } | { ok: false, error } so callers can use the error
+ * string in user-facing slash command output.
+ */
+import type { PluginMarketplace, PluginMarketplaceEntry, PluginEntrySource, ValidationResult } from "./types.js";
+export declare function validatePluginEntrySource(raw: unknown, path: string): ValidationResult<PluginEntrySource>;
+export declare function validatePluginEntry(raw: unknown, index: number): ValidationResult<PluginMarketplaceEntry>;
+export declare function validateMarketplace(raw: unknown): ValidationResult<PluginMarketplace>;