shennian 0.2.43 → 0.2.47

package/dist/src/agents/claude.d.ts

@@ -1,6 +1,7 @@
 import { AgentAdapter } from './adapter.js';
 export declare function normalizeClaudeModelId(modelId?: string | null): string;
 export declare class ClaudeAdapter extends AgentAdapter {
+    private readonly options;
     readonly type: "claude";
     private process;
     private agentSessionId;
@@ -10,6 +11,10 @@ export declare class ClaudeAdapter extends AgentAdapter {
     private runId;
     private hasEmittedText;
     private terminalState;
+    constructor(options?: {
+        systemPrompt?: string;
+        hidden?: boolean;
+    });
     start(sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
     send(text: string, modelId?: string): Promise<void>;
     resume(agentSessionId: string): Promise<void>;

package/dist/src/agents/claude.js

@@ -8,6 +8,7 @@ export function normalizeClaudeModelId(modelId) {
     return trimmed || 'default';
 }
 export class ClaudeAdapter extends AgentAdapter {
+    options;
     type = 'claude';
     process = null;
     agentSessionId = null;
@@ -17,6 +18,10 @@ export class ClaudeAdapter extends AgentAdapter {
     runId = '';
     hasEmittedText = false;
     terminalState = 'open';
+    constructor(options = {}) {
+        super();
+        this.options = options;
+    }
     async start(sessionId, workDir, agentSessionId) {
         this.sessionId = sessionId;
         this.workDir = workDir;
@@ -29,6 +34,12 @@ export class ClaudeAdapter extends AgentAdapter {
         this.runId = randomUUID();
         this.resetRunState();
         const args = ['-p', text, '--output-format', 'stream-json', '--verbose'];
+        if (this.options.systemPrompt) {
+            args.push('--append-system-prompt', this.options.systemPrompt);
+        }
+        if (this.options.hidden) {
+            args.push('--name', 'Shennian Manager Substrate');
+        }
         if (process.getuid?.() !== 0) {
             args.push('--dangerously-skip-permissions');
         }
@@ -44,6 +55,12 @@ export class ClaudeAdapter extends AgentAdapter {
         this.runId = randomUUID();
         this.resetRunState();
         const resumeArgs = ['--resume', agentSessionId, '--output-format', 'stream-json', '--verbose'];
+        if (this.options.systemPrompt) {
+            resumeArgs.push('--append-system-prompt', this.options.systemPrompt);
+        }
+        if (this.options.hidden) {
+            resumeArgs.push('--name', 'Shennian Manager Substrate');
+        }
         if (process.getuid?.() !== 0) {
             resumeArgs.push('--dangerously-skip-permissions');
         }

package/dist/src/agents/codex.d.ts

@@ -1,5 +1,6 @@
 import { AgentAdapter } from './adapter.js';
 export declare class CodexAdapter extends AgentAdapter {
+    private readonly options;
     readonly type: "codex";
     private process;
     private workDir;
@@ -20,6 +21,10 @@ export declare class CodexAdapter extends AgentAdapter {
     private namedThread;
     private deltaItemIds;
     private lastTransientStatus;
+    constructor(options?: {
+        modelInstructionsFile?: string;
+        hidden?: boolean;
+    });
     start(_sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
     send(text: string, modelId?: string): Promise<void>;
     resume(agentSessionId: string): Promise<void>;

package/dist/src/agents/codex.js

@@ -6,6 +6,7 @@ import { AgentAdapter, registerAgent } from './adapter.js';
 import { resolveBuiltinCommand, spawnResolvedCommand } from './command-spec.js';
 import { buildAgentProcessEnv } from '../agent-env.js';
 export class CodexAdapter extends AgentAdapter {
+    options;
     type = 'codex';
     process = null;
     workDir = null;
@@ -26,6 +27,10 @@ export class CodexAdapter extends AgentAdapter {
     namedThread = false;
     deltaItemIds = new Set();
     lastTransientStatus = '';
+    constructor(options = {}) {
+        super();
+        this.options = options;
+    }
     async start(_sessionId, workDir, agentSessionId) {
         this.workDir = workDir;
         this.seq = 0;
@@ -119,7 +124,11 @@ export class CodexAdapter extends AgentAdapter {
             this.emit('error', new Error('Command "codex" not found. Is OpenAI Codex CLI installed?'));
             return;
         }
-        const proc = spawnResolvedCommand(spec, ['app-server', '--listen', 'stdio://'], {
+        const args = ['app-server', '--listen', 'stdio://'];
+        if (this.options.modelInstructionsFile) {
+            args.push('-c', `model_instructions_file=${JSON.stringify(this.options.modelInstructionsFile)}`);
+        }
+        const proc = spawnResolvedCommand(spec, args, {
             cwd: this.workDir ?? undefined,
             stdio: ['pipe', 'pipe', 'pipe'],
             env: buildAgentProcessEnv({ NO_COLOR: '1' }),
@@ -193,6 +202,7 @@ export class CodexAdapter extends AgentAdapter {
                 approvalPolicy: 'never',
                 sandbox: 'danger-full-access',
                 persistExtendedHistory: true,
+                ...(this.options.hidden ? { threadSource: 'subagent' } : {}),
                 ...(codexModelId ? { model: codexModelId } : {}),
             });
             this.agentSessionId = response.thread?.id ?? this.agentSessionId;
@@ -204,6 +214,7 @@ export class CodexAdapter extends AgentAdapter {
             approvalPolicy: 'never',
             sandbox: 'danger-full-access',
             serviceName: 'Shennian',
+            threadSource: this.options.hidden ? 'subagent' : 'user',
             experimentalRawEvents: false,
             persistExtendedHistory: true,
             ...(codexModelId ? { model: codexModelId } : {}),

package/dist/src/agents/command-spec.js

@@ -1,6 +1,7 @@
 // @arch docs/architecture/cli/windows-agent-launch.md
 // @test src/__tests__/command-spec.test.ts
 import { spawn, spawnSync } from 'node:child_process';
+import os from 'node:os';
 import path from 'node:path';
 const BUILTIN_COMMANDS = {
     claude: [
@@ -24,6 +25,9 @@ const BUILTIN_COMMANDS = {
     pi: [
         { command: 'shennian', args: [], display: 'shennian' },
     ],
+    manager: [
+        { command: 'shennian', args: ['manager'], display: 'shennian manager' },
+    ],
 };
 const availabilityCache = new Map();
 const resolvedCache = new Map();
@@ -44,19 +48,82 @@ function splitLines(text) {
         .map((line) => line.trim())
         .filter(Boolean);
 }
+function getFallbackCommandCandidates(command) {
+    if (path.basename(command) !== command)
+        return [command];
+    const home = os.homedir();
+    if (getProcessPlatform() === 'win32') {
+        const names = path.extname(command)
+            ? [command]
+            : [command, `${command}.cmd`, `${command}.exe`, `${command}.bat`];
+        const appData = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+        const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+        const dirs = [
+            path.join(appData, 'npm'),
+            path.join(localAppData, 'pnpm'),
+            path.join(home, 'scoop', 'shims'),
+            path.join('C:\\', 'Program Files', 'nodejs'),
+        ];
+        return dirs.flatMap((dir) => names.map((name) => path.join(dir, name)));
+    }
+    const dirs = [
+        path.join(home, '.npm-global', 'bin'),
+        path.join(home, '.local', 'bin'),
+        path.join(home, '.bun', 'bin'),
+        '/opt/homebrew/bin',
+        '/usr/local/bin',
+        '/usr/bin',
+        '/bin',
+    ];
+    return dirs.map((dir) => path.join(dir, command));
+}
+function buildFallbackPathEnv(currentPath, command) {
+    const parts = currentPath?.split(path.delimiter).filter(Boolean) ?? [];
+    if (getProcessPlatform() === 'win32') {
+        if (command && path.basename(command) !== command) {
+            const commandDir = path.dirname(command);
+            if (!parts.includes(commandDir))
+                parts.unshift(commandDir);
+        }
+        return parts.join(path.delimiter);
+    }
+    if (command && path.basename(command) !== command) {
+        const commandDir = path.dirname(command);
+        if (!parts.includes(commandDir))
+            parts.unshift(commandDir);
+    }
+    for (const candidate of getFallbackCommandCandidates('shennian')) {
+        const dir = path.dirname(candidate);
+        if (!parts.includes(dir))
+            parts.push(dir);
+    }
+    return parts.join(path.delimiter);
+}
 function lookupCommandPaths(command) {
     if (pathLookupCache.has(command)) {
         return pathLookupCache.get(command) ?? [];
     }
-    const lookup = getProcessPlatform() === 'win32' ? 'where' : 'which';
+    const isWindows = getProcessPlatform() === 'win32';
+    const lookup = isWindows ? 'where' : 'which';
     const result = spawnSync(lookup, [command], {
         encoding: 'utf-8',
         stdio: ['ignore', 'pipe', 'pipe'],
         timeout: 3000,
+        env: {
+            ...process.env,
+            PATH: isWindows ? process.env.PATH : buildFallbackPathEnv(process.env.PATH, command),
+        },
     });
     const paths = result.status === 0 ? splitLines(result.stdout ?? '') : [];
-    pathLookupCache.set(command, paths);
-    return paths;
+    const withFallbacks = [...paths];
+    if (!isWindows) {
+        for (const candidate of getFallbackCommandCandidates(command)) {
+            if (!withFallbacks.includes(candidate))
+                withFallbacks.push(candidate);
+        }
+    }
+    pathLookupCache.set(command, withFallbacks);
+    return withFallbacks;
 }
 function getWindowsShellPath() {
     return process.env.ComSpec || 'cmd.exe';
@@ -286,6 +353,10 @@ export function spawnCommandString(commandString, runtimeArgs, options = {}) {
     return spawn(launch.command, launch.args, {
         ...options,
         cwd: launch.cwd,
+        env: {
+            ...options.env,
+            PATH: buildFallbackPathEnv(options.env?.PATH ?? process.env.PATH, parts[0]),
+        },
         ...(getProcessPlatform() === 'win32' && invocation?.kind === 'cmd-shim'
             ? { windowsVerbatimArguments: true }
             : {}),

package/dist/src/agents/detect.js

@@ -1,7 +1,7 @@
 import { AVAILABLE_BUILTIN_AGENT_TYPES } from '@shennian/wire';
 import { loadConfig } from '../config/index.js';
 import { getCommandVersion, resolveBuiltinCommand } from './command-spec.js';
-const AGENTS = AVAILABLE_BUILTIN_AGENT_TYPES.filter((agent) => agent !== 'pi');
+const AGENTS = AVAILABLE_BUILTIN_AGENT_TYPES.filter((agent) => agent !== 'pi' && agent !== 'manager');
 function getCustomAgentModels(caps) {
     const ids = caps.models?.length
         ? caps.models
@@ -16,9 +16,19 @@ function getCustomAgentModels(caps) {
     }));
 }
 export function detectAgents() {
-    // Pi agent is always available (built-in, platform-powered)
+    // Pi and Manager are always available. Manager delegates to Codex/Claude at run time.
     const detected = [
         { type: 'pi', command: 'shennian', args: [], version: undefined },
+        {
+            type: 'manager',
+            command: 'shennian',
+            args: ['manager'],
+            version: undefined,
+            models: [
+                { id: 'codex', name: 'Codex', provider: 'shennian', isDefault: true },
+                { id: 'claude', name: 'Claude Code', provider: 'shennian' },
+            ],
+        },
     ];
     for (const agent of AGENTS) {
         const spec = resolveBuiltinCommand(agent);

package/dist/src/agents/manager.d.ts

@@ -0,0 +1,16 @@
+import { AgentAdapter } from './adapter.js';
+export declare class ManagerAdapter extends AgentAdapter {
+    readonly type: "manager";
+    private inner;
+    private sessionId;
+    private workDir;
+    private agentSessionId;
+    private modelId;
+    start(sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
+    send(text: string, modelId?: string): Promise<void>;
+    resume(agentSessionId: string): Promise<void>;
+    stop(): Promise<void>;
+    private bindInner;
+    private wrapEvent;
+    private withManagerEnv;
+}

package/dist/src/agents/manager.js

@@ -0,0 +1,145 @@
+// @arch docs/features/manager-agent.md
+// @test src/__tests__/manager-runtime.test.ts
+import { AgentAdapter, registerAgent } from './adapter.js';
+import { CodexAdapter } from './codex.js';
+import { ClaudeAdapter } from './claude.js';
+import { MANAGER_SYSTEM_PROMPT, buildManagerPrompt } from '../manager/prompt.js';
+import { getManagerRuntimeService } from '../manager/runtime.js';
+import fs from 'node:fs';
+import path from 'node:path';
+function normalizeManagerModel(modelId) {
+    return modelId === 'claude' ? 'claude' : 'codex';
+}
+function safeSessionDirName(sessionId) {
+    return sessionId.replace(/[^a-zA-Z0-9_.-]/g, '_');
+}
+function readProjectAgentsMd(workDir) {
+    const agentsPath = path.join(workDir, 'AGENTS.md');
+    try {
+        return fs.readFileSync(agentsPath, 'utf8').trim();
+    }
+    catch {
+        return '';
+    }
+}
+function managerInstructionsPath(workDir, sessionId) {
+    return path.join(workDir, '.shennian', 'runtime', 'manager', safeSessionDirName(sessionId), 'instructions.md');
+}
+function buildStableManagerInstructions(workDir, managerSessionId) {
+    const projectInstructions = readProjectAgentsMd(workDir);
+    const channelInstructions = getManagerRuntimeService()?.getManagerExternalChannelSystemPrompt(managerSessionId) ?? '';
+    const sections = [
+        '# Shennian Manager Instructions',
+        'This file is generated by Shennian for a Manager Agent substrate session. Do not edit it by hand.',
+        projectInstructions
+            ? `## Project Instructions\n\n${projectInstructions}`
+            : '',
+        `## Manager Instructions\n\n${MANAGER_SYSTEM_PROMPT}`,
+        channelInstructions
+            ? `## External Message Channel Instructions\n\n${channelInstructions}`
+            : '',
+    ].filter(Boolean);
+    return `${sections.join('\n\n')}\n`;
+}
+function ensureManagerInstructionsFile(workDir, sessionId) {
+    const filePath = managerInstructionsPath(workDir, sessionId);
+    const content = buildStableManagerInstructions(workDir, sessionId);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    try {
+        if (fs.readFileSync(filePath, 'utf8') === content)
+            return filePath;
+    }
+    catch {
+        // Write the generated instruction file below.
+    }
+    fs.writeFileSync(filePath, content);
+    return filePath;
+}
+export class ManagerAdapter extends AgentAdapter {
+    type = 'manager';
+    inner = null;
+    sessionId = '';
+    workDir = '';
+    agentSessionId = null;
+    modelId = 'codex';
+    async start(sessionId, workDir, agentSessionId) {
+        this.sessionId = sessionId;
+        this.workDir = workDir;
+        this.agentSessionId = agentSessionId ?? null;
+        getManagerRuntimeService()?.registerManager({
+            sessionId,
+            agentSessionId: this.agentSessionId,
+            workDir,
+            modelId: this.modelId,
+            status: 'idle',
+        });
+    }
+    async send(text, modelId) {
+        const nextModel = normalizeManagerModel(modelId);
+        if (!this.inner || nextModel !== this.modelId) {
+            await this.inner?.stop().catch(() => { });
+            this.inner?.removeAllListeners();
+            this.modelId = nextModel;
+            const instructionsFile = ensureManagerInstructionsFile(this.workDir, this.sessionId);
+            const systemPrompt = buildStableManagerInstructions(this.workDir, this.sessionId);
+            this.inner = nextModel === 'claude'
+                ? new ClaudeAdapter({ systemPrompt, hidden: true })
+                : new CodexAdapter({ modelInstructionsFile: instructionsFile, hidden: true });
+            this.bindInner(this.inner);
+            await this.inner.start(this.sessionId, this.workDir, this.agentSessionId);
+            getManagerRuntimeService()?.bindManagerAdapterEvents(this.sessionId, this.inner);
+        }
+        getManagerRuntimeService()?.registerManager({
+            sessionId: this.sessionId,
+            agentSessionId: this.agentSessionId,
+            workDir: this.workDir,
+            modelId: this.modelId,
+            status: 'running',
+        });
+        await getManagerRuntimeService()?.ready();
+        await this.withManagerEnv(() => this.inner.send(buildManagerPrompt(text)));
+    }
+    async resume(agentSessionId) {
+        this.agentSessionId = agentSessionId;
+        if (this.inner)
+            await this.inner.resume(agentSessionId);
+    }
+    async stop() {
+        await this.inner?.stop();
+    }
+    bindInner(inner) {
+        inner.on('agentEvent', (event) => {
+            if (event.agentSessionId)
+                this.agentSessionId = event.agentSessionId;
+            this.emit('agentEvent', this.wrapEvent(event));
+        });
+        inner.on('error', (error) => this.emit('error', error));
+    }
+    wrapEvent(event) {
+        return {
+            ...event,
+            source: event.source ?? this.modelId,
+            agentSessionId: event.agentSessionId ?? this.agentSessionId ?? undefined,
+        };
+    }
+    async withManagerEnv(work) {
+        const env = getManagerRuntimeService()?.getInjectedEnv(this.sessionId, this.agentSessionId, this.workDir, this.modelId) ?? {};
+        const previous = new Map();
+        for (const [key, value] of Object.entries(env)) {
+            previous.set(key, process.env[key]);
+            process.env[key] = value;
+        }
+        try {
+            return await work();
+        }
+        finally {
+            for (const [key, value] of previous) {
+                if (value === undefined)
+                    delete process.env[key];
+                else
+                    process.env[key] = value;
+            }
+        }
+    }
+}
+registerAgent('manager', () => new ManagerAdapter());

package/dist/src/agents/model-registry/discovery.js

@@ -126,6 +126,10 @@ const fallbackPiModels = [
     { id: 'qwen3.6-plus', name: 'Qwen 3.6 Plus', provider: 'dashscope', isDefault: true },
     { id: 'qwen3.6-flash', name: 'Qwen 3.6 Flash', provider: 'dashscope' },
 ];
+const managerModels = [
+    { id: 'codex', name: 'Codex', provider: 'shennian', isDefault: true },
+    { id: 'claude', name: 'Claude Code', provider: 'shennian' },
+];
 async function discoverPiModels(context) {
     if (!context.serverUrl || !context.authToken)
         return fallbackPiModels;
@@ -167,6 +171,8 @@ async function discoverBuiltinModels(type, context) {
             return discoverOpenCodeModels();
         case 'pi':
             return discoverPiModels(context);
+        case 'manager':
+            return managerModels;
     }
 }
 export async function discoverModelsForAgent(agent, context) {

package/dist/src/agents/pi.d.ts

@@ -26,6 +26,7 @@ export declare class PiAdapter extends AgentAdapter {
     private lastSummaryMsgCount;
     private pendingBaseMessages;
     private finalizePromise;
+    private sendGeneration;
     private pendingSendStart;
     start(sessionId: string, workDir: string, _agentSessionId?: string | null): Promise<void>;
     send(text: string, modelId?: string): Promise<void>;

package/dist/src/agents/pi.js

@@ -394,6 +394,7 @@ export class PiAdapter extends AgentAdapter {
     lastSummaryMsgCount = 0;
     pendingBaseMessages = [];
     finalizePromise = Promise.resolve();
+    sendGeneration = 0;
     pendingSendStart = null;
     async start(sessionId, workDir, _agentSessionId) {
         this.sessionId = sessionId;
@@ -407,7 +408,16 @@ export class PiAdapter extends AgentAdapter {
         this.loadSummary();
     }
     async send(text, modelId) {
-        this.agent?.abort();
+        const generation = ++this.sendGeneration;
+        const interruptedMessages = this.agent && this.terminalState === 'open'
+            ? cloneMessages(this.pendingBaseMessages)
+            : null;
+        if (interruptedMessages) {
+            this.agent?.abort();
+            this.agent = null;
+            this.restoredMessages = interruptedMessages;
+            this.finalizePromise = Promise.resolve();
+        }
         const config = loadConfig();
         const authToken = config.machineToken ?? config.accessToken;
         if (!authToken) {
@@ -420,7 +430,7 @@ export class PiAdapter extends AgentAdapter {
             return;
         }
         this.authToken = authToken;
-        this.proxyUrl = (config.serverUrl ?? SERVERS.global.url).replace(/\/$/, '');
+        this.proxyUrl = (config.serverUrl ?? SERVERS.cn.url).replace(/\/$/, '');
         this.runId = randomUUID();
         this.seq = 0;
         this.emittedLengths.clear();
@@ -438,10 +448,14 @@ export class PiAdapter extends AgentAdapter {
         this.emit('agentEvent', { state: 'init', runId, seq: ++this.seq });
         void this.agent.prompt(text)
             .then(async () => {
+            if (generation !== this.sendGeneration)
+                return;
             this.resolvePendingSendStart(runId);
             await this.finalizePromise.catch(() => { });
         })
             .catch((err) => {
+            if (generation !== this.sendGeneration)
+                return;
             this.rejectPendingSendStart(runId, err);
             if (this.terminalState !== 'open')
                 return;
@@ -500,6 +514,8 @@ export class PiAdapter extends AgentAdapter {
             });
         }
         agent.subscribe((evt) => {
+            if (this.agent !== agent)
+                return;
             if (this.terminalState !== 'open')
                 return;
             const seq = ++this.seq;

package/dist/src/channels/base.d.ts

@@ -0,0 +1,62 @@
+export type ExternalChannelType = 'wecom' | 'websocket';
+export type ExternalChannelConfig = {
+    id: string;
+    type: ExternalChannelType;
+    name: string;
+    managerSessionId: string;
+    workDir: string;
+    enabled: boolean;
+    secretRef: string;
+};
+export type ExternalChannelView = {
+    id: string;
+    type: ExternalChannelType;
+    name: string;
+    managerSessionId: string;
+    workDir: string;
+    enabled: boolean;
+    wsUrl?: string;
+    token?: string;
+    tokenConfigured?: boolean;
+    canReply?: boolean;
+    systemPrompt?: string;
+};
+export type ExternalMessageEvent = {
+    type: 'external.message';
+    channelId: string;
+    channelType: ExternalChannelType;
+    conversationId: string;
+    messageId: string;
+    sender: {
+        id: string;
+        name?: string | null;
+    };
+    text: string;
+    attachments: Array<{
+        type: string;
+        name?: string;
+        url?: string;
+        mimeType?: string;
+        size?: number;
+    }>;
+    receivedAt: string;
+    replyTarget: string;
+    rawRef?: string | null;
+};
+export type ExternalReply = {
+    channelId: string;
+    conversationId: string;
+    text: string;
+    messageId?: string;
+    idempotencyKey?: string;
+};
+export interface ExternalChannelAdapter {
+    readonly type: ExternalChannelType;
+    connect(config: ExternalChannelConfig): Promise<void>;
+    disconnect(config: ExternalChannelConfig): Promise<void>;
+    send(config: ExternalChannelConfig, reply: ExternalReply): Promise<void>;
+    health(config: ExternalChannelConfig): Promise<{
+        ok: boolean;
+        message?: string;
+    }>;
+}

package/dist/src/channels/base.js

@@ -0,0 +1,3 @@
+// @arch docs/features/manager-agent.md
+// @test src/__tests__/manager-runtime.test.ts
+export {};

package/dist/src/channels/registry.d.ts

@@ -0,0 +1,7 @@
+import type { ExternalChannelConfig } from './base.js';
+export declare class ChannelConfigRegistry {
+    list(): ExternalChannelConfig[];
+    get(channelId: string): ExternalChannelConfig | undefined;
+    upsert(config: ExternalChannelConfig): void;
+    replaceAll(channels: ExternalChannelConfig[]): void;
+}

package/dist/src/channels/registry.js

@@ -0,0 +1,30 @@
+// @arch docs/features/manager-agent.md
+// @test src/__tests__/manager-runtime.test.ts
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveShennianPath } from '../config/index.js';
+const CHANNELS_PATH = resolveShennianPath('channels.json');
+export class ChannelConfigRegistry {
+    list() {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(CHANNELS_PATH, 'utf-8'));
+            return parsed.channels ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    get(channelId) {
+        return this.list().find((channel) => channel.id === channelId);
+    }
+    upsert(config) {
+        const channels = this.list().filter((channel) => channel.id !== config.id);
+        channels.push(config);
+        fs.mkdirSync(path.dirname(CHANNELS_PATH), { recursive: true });
+        fs.writeFileSync(CHANNELS_PATH, JSON.stringify({ channels }, null, 2));
+    }
+    replaceAll(channels) {
+        fs.mkdirSync(path.dirname(CHANNELS_PATH), { recursive: true });
+        fs.writeFileSync(CHANNELS_PATH, JSON.stringify({ channels }, null, 2));
+    }
+}