@chatcode/cco-market 1.45.1

package/lib/types/region-probe.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Deciding a download region by asking the network, once.
+ *
+ * The alternative was reading the system time zone, and it is wrong for
+ * exactly the people who most need this to work: someone in Shanghai behind
+ * a corporate proxy or a VPN reaches the official registry perfectly well
+ * and would be routed onto mirrors they do not need, while a Chinese-locale
+ * machine sitting in Singapore would be routed onto mirrors that are further
+ * away than the origin. A time zone says where a clock is. It does not say
+ * what the network can reach, which is the only question here.
+ *
+ * So the probe measures the thing itself: it asks both registries for the
+ * same small document and takes whichever answers first. That is
+ * self-correcting in a way a lookup table cannot be — the machine behind the
+ * proxy measures fast official access and stays global, without anyone
+ * having to enumerate the exceptions.
+ *
+ * It runs ONCE, when no region has ever been decided, and its answer is
+ * persisted as the decision. Re-probing every boot would let a market
+ * silently change routes between runs, which is the kind of behaviour that
+ * makes "it was fast yesterday" impossible to debug.
+ */
+import { type Region } from './regions.ts';
+/**
+ * Ask every region's registry the same question; return whichever answers
+ * first.
+ *
+ * First-past-the-post rather than a latency comparison, deliberately. From
+ * inside China the official registry usually does answer eventually, so
+ * "did it fail" is the wrong test and "which came back first" is the right
+ * one. From outside, the mainland mirror is reachable but further, and the
+ * same rule picks global. One rule, both directions, no thresholds to tune.
+ *
+ * @param timeoutMs - how long to wait before giving up on all of them.
+ * @param env - environment, for the registry overrides.
+ * @returns the winning region, or `global` when nothing answered — an
+ *   unreachable network is not evidence for switching routes.
+ */
+export declare function probeRegion(timeoutMs?: number, env?: NodeJS.ProcessEnv): Promise<Region>;
+/**
+ * The region to run under, probing only if nothing has ever decided one.
+ *
+ * @param stored - the region already on record, or undefined.
+ * @returns the region, and whether this call decided it (which is what earns
+ *   the user a one-time notice explaining the choice).
+ */
+export declare function resolveRegion(stored: Region | undefined, timeoutMs?: number, env?: NodeJS.ProcessEnv): Promise<{
+    region: Region;
+    probed: boolean;
+}>;

package/lib/types/regions.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Download regions: which route the market's own network requests take.
+ *
+ * Almost every external request the market makes lands on npm's registry or
+ * on GitHub — the plugin catalog, update checks, package downloads, author
+ * avatars, README screenshots. From mainland China several of those can be
+ * slow, which is why this is ONE setting rather than a
+ * row of them: "npm mirror", "GitHub proxy" and "image proxy" are three
+ * spellings of a single question the user is actually being asked, which is
+ * where they are.
+ *
+ * The routing table is the single source of truth. Every consumer asks it
+ * rather than reaching for a hardcoded host, so adding a region is a table
+ * entry instead of a search across six modules.
+ *
+ * Each route has a ChatCode-first environment escape hatch, with the former
+ * `DSHM_*` spelling retained only as a compatibility input.
+ * (src/registry.ts). The China route has service-specific public-proxy
+ * fallbacks; those come and go, and a user whose routes have died needs a way
+ * out that is not "wait for the next release".
+ */
+/** A region the market can download from. */
+export type Region = 'global' | 'china';
+/** Every region a user may pick. */
+export declare const REGIONS: readonly Region[];
+/** Narrow an untrusted value to a Region, or null. */
+export declare function asRegion(value: unknown): Region | null;
+/**
+ * The npm registry the market and pnpm read, no trailing slash.
+ *
+ * Exported because callers need to tell "this region uses the default" from
+ * "this region names a mirror" — the difference between leaving a spawned
+ * pnpm's registry alone and setting it.
+ */
+export declare const DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org";
+/** GitHub transports that fail independently on filtered networks. */
+export type GithubService = 'git' | 'raw' | 'avatar';
+/** A prefix proxy, or null for the canonical GitHub address. */
+export type GithubRoute = string | null;
+/** Ordered candidates per GitHub service. */
+export type GithubRoutes = Record<GithubService, GithubRoute[]>;
+/**
+ * One place the catalog can be read from.
+ *
+ * Two kinds because the two routes are genuinely different transports, not
+ * two URLs. The npm route reads a published package — which is what lets the
+ * catalog ride the same mirror as everything else, and gives it a version
+ * number that can be rolled back when a bad build ships.
+ */
+export type CatalogSource = {
+    kind: 'url';
+    url: string;
+} | {
+    kind: 'npm';
+    registry: string;
+    pkg: string;
+};
+/** Where one region sends each kind of request. `null` means "go direct". */
+export interface RegionRoutes {
+    /** npm registry base, no trailing slash. */
+    npmRegistry: string;
+    /** Prefix proxy for github.com-family URLs, or null to go direct. */
+    githubProxy: string | null;
+    /** Ordered routes per service; every list ends in a direct escape path. */
+    githubRoutes: GithubRoutes;
+    /**
+     * Where to look for the catalog, in order. Later entries are fallbacks.
+     *
+     * The catalog is the FIRST request the market makes, so a mirror that has
+     * gone down must mean a slow market rather than an empty one — every
+     * region ends its list at an address that has always worked.
+     */
+    catalog: CatalogSource[];
+}
+/**
+ * Normalize a user-maintained prefix, or reject it.
+ *
+ * Public mirrors receive the complete destination URL in their path. Only
+ * HTTPS prefixes without embedded credentials or query fragments are safe to
+ * persist and show again in the settings UI.
+ */
+export declare function normalizeGithubProxy(value: unknown): string | null;
+/** Apply (or clear) the persisted UI escape route. */
+export declare function setCustomGithubProxy(proxy: string | null): void;
+/** Whether the operator-owned environment variable disables UI changes. */
+export declare function githubProxyManaged(env?: NodeJS.ProcessEnv): boolean;
+/** Remember one verified route without changing other GitHub services. */
+export declare function rememberGithubRoute(service: GithubService, route: GithubRoute): void;
+/** Forget learned winners after the configured candidates change. */
+export declare function resetGithubRoutePreferences(): void;
+/**
+ * The routes for a region, with environment overrides applied.
+ *
+ * Overrides win over the table because they are the user's statement about
+ * their own network, and they are the way out when a public proxy dies.
+ *
+ * `CHATCODE_CLI_MARKET_REGISTRY_URL` names the catalog URL. The former
+ * `DSHM_REGISTRY_URL` spelling keeps the same meaning as a compatibility
+ * input. When set, either form
+ * when set it REPLACES the source list rather than heading it: someone
+ * pointing the market at their own catalog does not want it quietly
+ * reverting to ours.
+ */
+export declare function routesFor(region: Region, env?: NodeJS.ProcessEnv): RegionRoutes;
+/** Ordered candidates with this process's last verified winner first. */
+export declare function githubRoutesFor(service: GithubService, region?: Region, env?: NodeJS.ProcessEnv): GithubRoute[];
+/** The region in force. */
+export declare function activeRegion(): Region;
+/** Set the region in force. Callers are responsible for their own caches. */
+export declare function setActiveRegion(region: Region): void;
+/**
+ * Wrap a github.com-family URL in a prefix proxy.
+ *
+ * The proxy takes the full absolute URL as its path (`{proxy}/{url}`) rather
+ * than a rewritten hostname, so the same joining rule works for every
+ * GitHub service a caller has explicitly allowed through public routes.
+ *
+ * @param proxy - the prefix, or null to go direct.
+ * @param url - an absolute https URL on a github.com-family host.
+ * @returns the proxied URL, or `url` unchanged when there is no proxy.
+ */
+export declare function throughProxy(proxy: string | null, url: string): string;

package/lib/types/registry.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Registry access: the curated list from awesome-dsh-plugin.com, fetched
+ * fresh on every request. See `loadRegistry` for why there is nothing
+ * behind it any more.
+ */
+import { type Region } from './regions.ts';
+export interface RegistryPlugin {
+    name: string;
+    owner: string;
+    url: string;
+    /** One legacy category id or several category ids. */
+    category: string | string[];
+    description: Record<string, string>;
+    npm?: string | null;
+    tarball?: string | null;
+    stars?: number | null;
+    /**
+     * npm downloads in the last 30 days, when the entry has a published
+     * package. `null`/absent means "no npm package" — a coverage gap, not a
+     * zero — so sorting must not read it as "less popular than 0".
+     */
+    downloads?: number | null;
+    install: string;
+    added: string;
+    /**
+     * Catalog-side deprecation flags (#60): supplied by awesome-dsh-plugin,
+     * absent for every normal entry — the market only consumes them, so a
+     * catalog without the fields behaves exactly as before.
+     */
+    deprecated?: boolean;
+    /** Catalog name of the suggested replacement plugin, when deprecated. */
+    replacement?: string;
+}
+/**
+ * Category ids for one catalog entry, de-duplicated in declaration order.
+ *
+ * Catalog JSON is an external input, so malformed array members are omitted
+ * here and an entry with no usable category is rejected by `asRegistry`.
+ */
+export declare function pluginCategories(plugin: Pick<RegistryPlugin, 'category'>): string[];
+export interface Registry {
+    updated: string;
+    count: number;
+    categories: Record<string, Record<string, string>>;
+    plugins: RegistryPlugin[];
+}
+/**
+ * Drop what we remember, so the next call is unconditional.
+ *
+ * Exists for tests: the memo is module state, and a spec that asserted a
+ * 304 would otherwise leak a validator into the next one.
+ */
+export declare function forgetCatalog(): void;
+/**
+ * The catalog, revalidated every time it is asked for.
+ *
+ * There used to be three answers here — live, a one-hour in-memory cache,
+ * and a snapshot bundled into the npm package — and only the first was
+ * correct. The other two were indistinguishable from it on screen, so a
+ * machine that could not reach the registry browsed the publish-time file
+ * (839 entries against 1367 live, and frozen forever for anyone on an older
+ * release), while a machine that COULD reach it still saw an hour-old
+ * listing of a catalog that grows by ~250 entries a day.
+ *
+ * For a catalog, stale is not a degraded answer, it is a wrong one: a plugin
+ * published this morning reads as "does not exist". So there is one source
+ * now, and a failure is a failure — the caller reports it and offers a
+ * retry, which is a state the user can act on. In particular a network
+ * failure is NEVER answered from `served`: an origin that cannot be reached
+ * has not confirmed anything, and quietly handing back the last catalog
+ * would rebuild exactly the fallback this replaced.
+ * @throws when the catalog cannot be fetched or does not look like one.
+ */
+export declare function loadRegistry(region?: Region): Promise<Registry>;
+/**
+ * A catalog failure with the facts needed to classify it, in the message
+ * itself.
+ *
+ * The market shows this string and the log export carries it, so it is the
+ * whole of what a bug report will contain. "The operation was aborted due to
+ * timeout" alone cannot distinguish a slow link from a blocked one from a
+ * proxy this process cannot use — and Node's `fetch` ignores HTTP_PROXY
+ * entirely (measured on Node 25), so a machine whose only route out is a
+ * proxy fails here every time while every other tool on it works.
+ */
+export declare function describeFetchFailure(error: unknown, elapsedMs: number, attempts?: number): string;

package/lib/types/restart.d.ts

@@ -0,0 +1,194 @@
+/**
+ * Self-restart: relaunch the exact ChatCode CLI invocation that booted this host so
+ * pending (non-hot) plugin changes take effect without the user leaving the
+ * UI. Contributed in #14 by @ysyyhhh; ported onto the layered architecture.
+ *
+ * Safety model: the endpoint accepts only direct same-origin loopback
+ * requests (no forwarding headers), refuses while a plugin operation runs,
+ * and deployments under a supervisor (systemd/launchd/pm2) can disable the
+ * whole feature with `allowRestart: false` — the supervisor owns restarts.
+ */
+import type { IncomingMessage } from 'node:http';
+/** @internal test hook — production callers use detectedDebugger() only. */
+export declare function setDetectedDebuggerOverride(value: 'inspector' | null | undefined): void;
+/**
+ * The process supervisor running this host, when one can be identified —
+ * `null` when nothing says so.
+ *
+ * This exists because the failure it prevents is the worst one the market
+ * can cause. Under systemd's default `KillMode=control-group`, everything in
+ * the unit's cgroup dies with the main process — including the detached
+ * helper that was supposed to bring the replacement up. So "restart" killed
+ * a production service and nothing came back (#229 by @SkillBase-Al: "杀死了
+ * 服务但是无法重复启动服务"). `allowRestart: false` was always the documented
+ * answer, but it is opt-in, and nothing told the operator to opt in until
+ * after they had already lost the service.
+ *
+ * TWO signals are required, and the second is the whole reason this function
+ * is not a one-line env check. `INVOCATION_ID` is INHERITED: every
+ * descendant of a systemd unit carries it, which on Linux includes an
+ * ordinary desktop terminal (its shell descends from a user-session unit)
+ * and a CI runner (the agent is a unit — this repo's own smoke test caught
+ * that). Treating inheritance as ownership would disable the button for a
+ * large population of hosts where it works fine, which is a worse bug than
+ * the one being fixed.
+ *
+ * The parent test is what distinguishes being the unit's own main process
+ * from merely descending from one: a terminal's node has the shell as its
+ * parent and a runner's has the agent. It used to be `ppid === 1`, which is
+ * only true for SYSTEM units. A per-user unit's service is forked by that
+ * user's manager instance — `systemd --user`, an ordinary PID — so user-unit
+ * hosts read as unsupervised, and one-click restart killed them for good
+ * (#471 by @automagik-genie, with the journal to prove the whole chain:
+ * clean SIGTERM exit → `Restart=on-failure` does not fire → `KillMode=mixed`
+ * SIGKILLs the detached helper before it can spawn the replacement). So the
+ * parent counts as a manager when it is PID 1 or its comm is `systemd` —
+ * the one name both manager instances share and the false-positive parents
+ * (shells, CI agents) never carry. `/proc` is Linux-only, which is exactly
+ * as wide as systemd itself; anywhere it cannot be read the answer stays
+ * "not a manager".
+ *
+ * Scoped to systemd on purpose. pm2 sets `pm_id`, but it is inherited the
+ * same way and pm2's God daemon — not PID 1 — is the parent, so there is no
+ * equivalent second signal; a guess there would reintroduce exactly the
+ * false positive this pair exists to avoid. launchd has no marker at all.
+ * Both still need the explicit setting: detection is a safety net over the
+ * documented option, never a replacement for it.
+ */
+export declare function detectedSupervisor(env?: NodeJS.ProcessEnv, ppid?: number, parentComm?: (pid: number) => string | null): string | null;
+/**
+ * Whether this host process is under a debugger, when one can be identified —
+ * `'inspector'` or `null`.
+ *
+ * Parallel to `detectedSupervisor()` (#229): a runtime latch for the restart
+ * route and status poll, NOT an entry in `restartAllowed()`. Folding it into
+ * `restartAllowed()` would write `allowRestart: false` through the settings
+ * page while a debug session is open, and the switch would stay off after
+ * the debugger detaches (#447).
+ *
+ * An explicit `allowRestart: true` does NOT override this latch either —
+ * unlike systemd, there is no documented deployment shape where killing a
+ * debug-attached host from the market UI is the right answer.
+ *
+ * Primary signal: `inspector.url()` is set (covers `--inspect` at boot,
+ * `inspector.open()`, and SIGUSR1 attach). Secondary: inspect-family flags
+ * in `execArgv` and `NODE_OPTIONS`, matched by token prefix — not a
+ * `/inspect/` substring, so script paths like `.../inspect-tool.js` do not
+ * false-positive. Includes `--inspect-wait` for Node versions that expose it
+ * as a distinct flag before `inspector.url()` is populated.
+ *
+ * Accepted false positive (same trade as #229 not guessing pm2): a host left
+ * listening on an inspector port — including `NODE_OPTIONS=--inspect` with
+ * nobody attached — is treated as debug-owned and gets no one-click restart.
+ */
+export declare function detectedDebugger(inspectorUrl?: string | undefined, execArgv?: readonly string[], nodeOptions?: string): 'inspector' | null;
+/**
+ * Self-restart is enabled by default, disabled by an explicit false — and
+ * disabled by DEFAULT under a detected supervisor, which owns restarts and
+ * whose process group would take the replacement helper down with it.
+ *
+ * An explicit `true` still wins: an operator who has configured their unit
+ * for it (`KillMode=process`, or a wrapper that survives) is making a
+ * statement about their own deployment, and this should not overrule it.
+ */
+export declare function restartAllowed(config: {
+    allowRestart?: boolean;
+}, env?: NodeJS.ProcessEnv, ppid?: number): boolean;
+/**
+ * The port this process is serving on, read off the request that asked for
+ * the restart.
+ *
+ * The alternative is to parse it out of the launch argv, which is wrong for
+ * every host that binds from config or an env var. The Host header is what
+ * the browser actually reached us on, so it is the port the replacement has
+ * to take over — and it is already validated against Origin by the guard
+ * below before any of this runs.
+ * @returns the port, or null when the header carries none (a default port).
+ */
+export declare function servingPort(request: Pick<IncomingMessage, 'headers'>): number | null;
+/** Whether a process-control request came from this Web host on loopback. */
+export declare function trustedRestartRequest(request: Pick<IncomingMessage, 'headers' | 'socket'>): boolean;
+/**
+ * Whether a download navigation may fetch a sensitive GET export.
+ * Browsers do NOT send an Origin header on same-origin GET navigations
+ * (`<a href="/..." download>`), so unlike process-control requests a missing
+ * Origin is the NORMAL shape of a user-initiated download and must pass.
+ * Keep the rest of the posture: loopback peer only, no proxy forwarding
+ * headers, and — when an Origin IS present (fetch/CORS attempts) — it must
+ * still match Host so a cross-origin page cannot read the export.
+ */
+export declare function trustedDownloadRequest(request: Pick<IncomingMessage, 'headers' | 'socket'>): boolean;
+/** The exact boot invocation the detached restart helper replays. */
+export declare function restartLaunch(): {
+    file: string;
+    args: string[];
+    cwd: string;
+    viaShell: boolean;
+};
+/**
+ * Platform-correct spawn invocation for the replacement host (#40 by
+ * @1123762794): on Windows a `detached` spawn maps to DETACHED_PROCESS — the
+ * new host gets NO console, and every console child it later spawns (e.g.
+ * ChatCode CLI sandbox tool runners) pops a visible node window. Wrapping the launch
+ * in `powershell -WindowStyle Hidden` gives the host a HIDDEN console that
+ * children inherit instead. POSIX keeps the plain detached spawn.
+ */
+export declare function respawnInvocation(launch: {
+    file: string;
+    args: string[];
+    viaShell: boolean;
+}, platform?: NodeJS.Platform): {
+    file: string;
+    args: string[];
+    viaShell: boolean;
+    detached: boolean;
+};
+/** What scheduleRestart reports back to the caller for logging/response. */
+export interface RestartResult {
+    pid: number;
+    helperPid: number | undefined;
+    logOut: string;
+    logErr: string;
+}
+/**
+ * Source for the detached helper that outlives this process and brings the
+ * replacement up.
+ *
+ * Extracted so the waiting can be tested by RUNNING it, which is the only
+ * way this class of bug shows itself: every part of the old helper looked
+ * right in isolation.
+ *
+ * What it fixes (#177, reported on Windows 11, reproducible every time): the
+ * helper slept a flat 1500ms and spawned. The old process had exited, but
+ * the listening socket had not been released yet, so the replacement died
+ * instantly with EADDRINUSE — and the spawn was wrapped in `catch {}`, so
+ * nothing was written anywhere. The user saw a restart button that did
+ * nothing. The docstring above it even claimed the helper "waits for our
+ * port to free up"; it never did.
+ *
+ * So: wait for the port to actually go quiet, then start, then CHECK that
+ * something came up, and write a diagnosis when it did not. A restart that
+ * fails must leave evidence — this one is invisible by construction, since
+ * the process that would have logged it is the one that just exited.
+ * @param port - the port the replacement must bind; when unknown, the helper
+ *   falls back to the old fixed delay, which is better than nothing.
+ */
+export declare function restartHelperSource(spawned: {
+    file: string;
+    args: string[];
+    viaShell: boolean;
+    detached: boolean;
+}, launch: {
+    cwd: string;
+}, logs: {
+    out: string;
+    err: string;
+}, port: number | null): string;
+/**
+ * Relaunch this exact ChatCode CLI entry after a detached handoff, then stop this
+ * process. The helper outlives us (detached + unref), waits for our port to
+ * be released before starting the replacement, and logs under tmpdir.
+ * @param port - the port this process is serving on, so the helper can wait
+ *   for it rather than guessing at a delay.
+ */
+export declare function scheduleRestart(port?: number | null): RestartResult;

package/lib/types/routes.d.ts

@@ -0,0 +1,67 @@
+/**
+ * HTTP routes bridging the browser market UI to the host. This layer only
+ * parses requests, calls the service modules, and serializes responses —
+ * process spawning lives in dsh-cli.ts, filesystem reads in profile.ts,
+ * orchestration in install.ts / themes.ts / updates.ts.
+ *
+ * Security: the install route executes a shell command, so it accepts only
+ * same-origin POSTs and only sources present in the curated registry.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { type PluginCommandRuntime } from './dsh-cli.ts';
+import { type AgentsLookup } from './agents.ts';
+import { type Channel } from './channels.ts';
+import { type Region } from './regions.ts';
+import { type LoaderEntry } from './themes.ts';
+export type { LoaderEntry } from './themes.ts';
+export type { UpdateStatus } from './updates.ts';
+export interface WebServerService {
+    register(route: {
+        kind: 'exact' | 'prefix';
+        path: string;
+        handler: (request: IncomingMessage, response: ServerResponse) => void | Promise<void>;
+    }): () => void;
+}
+export interface MarketHost {
+    webServer: WebServerService;
+    loader: {
+        entries(): Iterable<LoaderEntry>;
+    };
+    plugin(plugin: unknown, config: unknown): {
+        await(): Promise<unknown>;
+        dispose(): Promise<unknown> | void;
+    };
+    on?(event: string, callback: (fiber: {
+        entry?: {
+            options?: {
+                name?: string;
+            };
+        };
+    }) => void): () => void;
+    logger?: {
+        info?(message: string): void;
+        warn(message: string): void;
+    };
+}
+export interface MarketConfig {
+    /** Profile the market installs into; matches the profile serving this UI. */
+    profile: string;
+    /** Host-authoritative profile directory; ordinary DSH derives it from DSH_HOME. */
+    profileDirectory?: string;
+    /** Detached self-restart is unsafe under systemd/launchd/pm2; operators can disable it (#14). */
+    allowRestart?: boolean;
+    /** Which release channel the market offers ITSELF from; other plugins never follow it. */
+    channel?: Channel;
+    /** Which mirrors every outbound request uses; undefined until decided. */
+    region?: Region;
+    /** Snapshots retained per profile (issue #98); defaults to DEFAULT_MAX_SNAPSHOTS. */
+    maxSnapshots?: number;
+}
+export declare function marketVersion(): string;
+/**
+ * Register the market's HTTP routes.
+ * @param host - Acquired webServer + shell services.
+ * @param config - Validated market configuration.
+ * @returns Disposer removing every registered route.
+ */
+export declare function mountMarketRoutes(host: MarketHost, config: MarketConfig, commandRuntime?: PluginCommandRuntime, agentsLookup?: AgentsLookup): () => void;

package/lib/types/settings.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The market's own settings namespace: the half that makes `allowRestart`
+ * a switch on the plugin configuration page instead of a line the user has
+ * to hand-write into cordis.yml.
+ *
+ * `allowRestart: false` is the documented answer for a host owned by
+ * systemd, launchd or pm2 — a supervisor restarts it, so the market's
+ * one-click restart must not launch a second one. Until now the only way to
+ * say that was editing YAML in the right place with the right indentation,
+ * where a stray space stops the profile booting.
+ *
+ * Only `allowRestart` is exposed. `profile` names which profile this
+ * instance manages: it is decided at mount from the composition or the
+ * command line, and a running instance cannot switch to another one, so
+ * offering it as a field would promise something the write cannot deliver.
+ *
+ * The release channel is NOT here either, and that is a correction rather
+ * than an omission. It was, briefly, and it made this namespace a second
+ * writer for a value the market already stores in its own state.json: the
+ * mount read the user's saved channel off disk, then `onChange` assigned
+ * `source().channel` — which knows nothing about that file — straight back
+ * over it. The choice survived exactly until the next settings event.
+ *
+ * Only a real host could show that; the unit lane mounts the routes without
+ * this layer at all. `allowRestart` needs this door because its only other
+ * one is hand-edited YAML. The channel has a control of its own on the
+ * plugin configuration page, so a second door bought nothing and cost the
+ * setting its memory.
+ *
+ * The wiring rides the scoped fiber, so a host with no settings service —
+ * every dsh before 0.1.0-rc.7 — simply never runs any of this and the entry
+ * configuration stands as composed. That is why this needs no version check
+ * of its own.
+ *
+ * It depends on the SERVICE and nothing else, which is the whole point of
+ * the shape below. This module used to import two convenience helpers,
+ * `installSettingsSection` and `settingsNamespace`, from
+ * `@deepseek-ai/dsh-settings`. dsh 0.1.2-alpha.1 deleted both — and a
+ * missing NAMED EXPORT is not a missing service. `ctx.inject` degrades
+ * quietly; an ESM named import that resolves to nothing is a SyntaxError at
+ * module evaluation, which cordis's loader reports as a failed entry and the
+ * host exits 1. Installing the market stopped the host from booting at all:
+ *
+ *   SyntaxError: The requested module '@deepseek-ai/dsh-settings' does not
+ *   provide an export named 'installSettingsSection'
+ *
+ * The service itself never changed — `sctx.settings.register(ns, schema,
+ * { base })` is identical in 0.1.0-rc.7 and 0.1.2-alpha.2. Only the two
+ * wrappers went away. So this inlines what the wrapper did (verified against
+ * its source: an inject, a register, a watch, and an unload effect) and
+ * validates the namespace here. Nothing about the graceful-degradation story
+ * changes; it just stops being conditional on an export that upstream is
+ * free to move.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+/** Namespace the card on the browser side keys itself to. */
+export declare const MARKET_SETTINGS_NS = "dsh-market";
+/** The market settings a user may edit at runtime. */
+export interface MarketSettings {
+    allowRestart: boolean;
+}
+export declare const MarketSettings: z<MarketSettings>;
+/**
+ * Wire the namespace so a saved change reaches the routes immediately.
+ *
+ * The routes read `allowRestart` off this object on every request (the
+ * status route reports the capability, the restart route enforces it), so
+ * updating it in place is what makes a toggle take effect without a
+ * restart — which would be a poor thing to require of a setting whose whole
+ * subject is restarting.
+ *
+ * @param ctx - the plugin context owning the wiring.
+ * @param resolved - the live config object the routes read.
+ */
+export declare function installMarketSettings(ctx: Context, resolved: {
+    allowRestart?: boolean;
+}): void;

package/lib/types/skill-market/api.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedSkillMarketConfig, SkillListQuery, SkillListResult } from './types.ts';
+/** Client for the public skill catalog and archive endpoints. */
+export declare class SkillMarketApi {
+    private readonly config;
+    constructor(config: ResolvedSkillMarketConfig);
+    /** Fetch one validated catalog page. */
+    list(query?: SkillListQuery, signal?: AbortSignal): Promise<SkillListResult>;
+    /** Download a skill archive; the caller consumes and size-caps the body. */
+    download(id: number, signal?: AbortSignal): Promise<Response>;
+}

package/lib/types/skill-market/config.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedSkillMarketConfig, SkillMarketConfig } from './types.ts';
+/** Resolve and validate deployment-varying skill-market settings. */
+export declare function resolveSkillMarketConfig(input: SkillMarketConfig | undefined): ResolvedSkillMarketConfig;

package/lib/types/skill-market/installer.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedSkillMarketConfig, InstalledSkill, SkillInstallLocation, SkillInstallResult } from './types.ts';
+import type { SkillMarketApi } from './api.ts';
+export declare const SKILL_MARKET_META_FILE = ".skill-market.json";
+/** Installs validated catalog archives into ChatCode CLI skill roots. */
+export declare class SkillMarketInstaller {
+    private readonly api;
+    private readonly config;
+    constructor(api: SkillMarketApi, config: ResolvedSkillMarketConfig);
+    /** Install or update one catalog skill for a local session workspace. */
+    install(options: {
+        readonly id: number;
+        readonly name: string;
+        readonly version?: string;
+        readonly location: SkillInstallLocation;
+        readonly cwd: string;
+        readonly signal?: AbortSignal;
+    }): Promise<SkillInstallResult>;
+    private downloadArchive;
+    /** List market-managed skills visible from a local session workspace. */
+    installed(cwd: string): Promise<readonly InstalledSkill[]>;
+}
+/** Resolve the two skill roots visible to a session workspace. */
+export declare function resolveSkillRoots(cwd: string): Promise<Record<SkillInstallLocation, string>>;

package/lib/types/skill-market/runtime.d.ts

@@ -0,0 +1,10 @@
+import { SkillMarketApi } from './api.ts';
+import { SkillMarketInstaller } from './installer.ts';
+import type { ResolvedSkillMarketConfig } from './types.ts';
+/** Shared skill-market operations consumed by Web routes and the terminal scene. */
+export declare class SkillMarketRuntime {
+    readonly config: ResolvedSkillMarketConfig;
+    readonly api: SkillMarketApi;
+    readonly installer: SkillMarketInstaller;
+    constructor(config: ResolvedSkillMarketConfig);
+}

package/lib/types/skill-market/tui.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { SkillMarketRuntime } from './runtime.ts';
+/** Register `/skill-market` and its full-screen terminal scene together. */
+export declare function installSkillMarketTui(ctx: Context, runtime: SkillMarketRuntime): void;