shennian 0.2.64 → 0.2.66

package/dist/src/agent-env.js

@@ -41,6 +41,7 @@ function readPosixShellEnv() {
             encoding: 'utf-8',
             stdio: ['ignore', 'pipe', 'ignore'],
             timeout: 1500,
+            windowsHide: true,
         });
         const parsed = typeof result.stdout === 'string' ? parseEnvJson(result.stdout) : null;
         if (parsed)
@@ -61,6 +62,7 @@ Write-Output '${SHELL_ENV_END}'
         encoding: 'utf-8',
         stdio: ['ignore', 'pipe', 'ignore'],
         timeout: 1500,
+        windowsHide: true,
     });
     return typeof result.stdout === 'string' ? parseEnvJson(result.stdout) : null;
 }

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

@@ -109,6 +109,7 @@ function lookupCommandPaths(command) {
         encoding: 'utf-8',
         stdio: ['ignore', 'pipe', 'pipe'],
         timeout: 3000,
+        windowsHide: true,
         env: {
             ...process.env,
             PATH: isWindows ? process.env.PATH : buildFallbackPathEnv(process.env.PATH, command),
@@ -192,6 +193,7 @@ function canUseWslBridge(command) {
     const result = spawnSync(wslPath, ['-e', 'sh', '-lc', `command -v ${quotePosixArg(command)} >/dev/null 2>&1`], {
         stdio: 'ignore',
         timeout: 5000,
+        windowsHide: true,
     });
     const ok = result.status === 0;
     wslAvailabilityCache.set(command, ok);
@@ -274,6 +276,7 @@ export function spawnResolvedCommand(spec, runtimeArgs, options = {}) {
     return spawn(launch.command, launch.args, {
         ...options,
         cwd: launch.cwd,
+        windowsHide: options.windowsHide ?? true,
         ...(getProcessPlatform() === 'win32' && spec.kind === 'cmd-shim'
             ? { windowsVerbatimArguments: true }
             : {}),
@@ -287,6 +290,7 @@ export function spawnResolvedCommandSync(spec, runtimeArgs, options = {}) {
     return spawnSync(launch.command, launch.args, {
         ...options,
         cwd: launch.cwd,
+        windowsHide: options.windowsHide ?? true,
         ...(getProcessPlatform() === 'win32' && spec.kind === 'cmd-shim'
             ? { windowsVerbatimArguments: true }
             : {}),
@@ -356,6 +360,7 @@ export function spawnCommandString(commandString, runtimeArgs, options = {}) {
     return spawn(launch.command, launch.args, {
         ...options,
         cwd: launch.cwd,
+        windowsHide: options.windowsHide ?? true,
         env: {
             ...options.env,
             PATH: buildFallbackPathEnv(options.env?.PATH ?? process.env.PATH, parts[0]),

package/dist/src/agents/config-status.d.ts

@@ -1,17 +1,18 @@
 import type { AgentConfigSummary, AgentType } from '@shennian/wire';
+export type ConfigurableAgent = 'codex' | 'claude' | 'pi';
 export type AgentProviderConfigRecord = {
-    agent: 'codex' | 'claude';
+    agent: ConfigurableAgent;
     baseUrl?: string;
     token?: string;
     updatedAt: string;
 };
-export declare function getManagedAgentProviderConfig(agent: 'codex' | 'claude'): AgentProviderConfigRecord | undefined;
+export declare function getManagedAgentProviderConfig(agent: ConfigurableAgent): AgentProviderConfigRecord | undefined;
 export declare function upsertManagedAgentProviderConfig(input: {
-    agent: 'codex' | 'claude';
+    agent: ConfigurableAgent;
     baseUrl?: string;
     token?: string;
 }): AgentProviderConfigRecord;
-export declare function deleteManagedAgentProviderConfig(agent: 'codex' | 'claude'): void;
+export declare function deleteManagedAgentProviderConfig(agent: ConfigurableAgent): void;
 export declare function buildManagedAgentEnv(agent: AgentType): NodeJS.ProcessEnv;
 export declare function getAgentConfigSummary(agent: AgentType, env?: NodeJS.ProcessEnv): AgentConfigSummary | undefined;
 export declare function maskToken(token: string): string;

package/dist/src/agents/config-status.js

@@ -4,9 +4,12 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { readLatestUserEnv } from '../agent-env.js';
-import { resolveShennianPath } from '../config/index.js';
+import { loadConfig, resolveShennianPath } from '../config/index.js';
 const MANAGED_CONFIG_PATH = resolveShennianPath('agent-provider-config.json');
 const TOKEN_SUFFIX_LENGTH = 4;
+function isConfigurableAgent(agent) {
+    return agent === 'codex' || agent === 'claude' || agent === 'pi';
+}
 const AGENT_ENV_KEYS = {
     codex: {
         baseUrl: ['OPENAI_BASE_URL', 'OPENAI_API_BASE', 'OPENAI_API_URL'],
@@ -16,6 +19,10 @@ const AGENT_ENV_KEYS = {
         baseUrl: ['ANTHROPIC_BASE_URL', 'ANTHROPIC_API_URL'],
         token: ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'],
     },
+    pi: {
+        baseUrl: ['DASHSCOPE_BASE_URL', 'DASHSCOPE_API_BASE', 'DASHSCOPE_API_URL'],
+        token: ['DASHSCOPE_API_KEY', 'DASHSCOPE_TOKEN'],
+    },
 };
 export function getManagedAgentProviderConfig(agent) {
     return loadManagedConfig().configs[agent];
@@ -39,7 +46,7 @@ export function deleteManagedAgentProviderConfig(agent) {
     saveManagedConfig(file);
 }
 export function buildManagedAgentEnv(agent) {
-    if (agent !== 'codex' && agent !== 'claude')
+    if (!isConfigurableAgent(agent))
         return {};
     const config = getManagedAgentProviderConfig(agent);
     if (!config)
@@ -50,13 +57,19 @@ export function buildManagedAgentEnv(agent) {
             OPENAI_API_KEY: config.token,
         });
     }
+    if (agent === 'claude') {
+        return compactEnv({
+            ANTHROPIC_BASE_URL: config.baseUrl,
+            ANTHROPIC_API_KEY: config.token,
+        });
+    }
     return compactEnv({
-        ANTHROPIC_BASE_URL: config.baseUrl,
-        ANTHROPIC_API_KEY: config.token,
+        DASHSCOPE_BASE_URL: config.baseUrl,
+        DASHSCOPE_API_KEY: config.token,
     });
 }
 export function getAgentConfigSummary(agent, env = readLatestUserEnv()) {
-    if (agent !== 'codex' && agent !== 'claude')
+    if (!isConfigurableAgent(agent))
         return undefined;
     const managed = getManagedAgentProviderConfig(agent);
     if (managed?.token || managed?.baseUrl) {
@@ -141,9 +154,17 @@ function firstEnv(env, keys) {
 }
 function detectFromKnownConfigFiles(agent) {
     const home = os.homedir();
+    if (agent === 'pi') {
+        const config = loadConfig();
+        const token = config.apiKeys?.dashscope?.trim();
+        if (token)
+            return { token, tokenPresent: true };
+    }
     const candidates = agent === 'codex'
         ? [path.join(home, '.codex', 'config.toml'), path.join(home, '.codex', 'auth.json')]
-        : [path.join(home, '.claude', 'settings.json'), path.join(home, '.claude.json')];
+        : agent === 'claude'
+            ? [path.join(home, '.claude', 'settings.json'), path.join(home, '.claude.json')]
+            : [path.join(home, '.dashscope', 'config.json')];
     for (const file of candidates) {
         const text = readSmallTextFile(file);
         if (!text)
@@ -167,15 +188,15 @@ function readSmallTextFile(file) {
     }
 }
 function extractBaseUrl(text) {
-    const match = text.match(/(?:base_url|baseURL|api_url|apiUrl|ANTHROPIC_BASE_URL|OPENAI_BASE_URL)["'\s:=]+([^"'\s,}]+)/i);
+    const match = text.match(/(?:base_url|baseURL|api_url|apiUrl|ANTHROPIC_BASE_URL|OPENAI_BASE_URL|DASHSCOPE_BASE_URL)["'\s:=]+([^"'\s,}]+)/i);
     return match?.[1]?.trim();
 }
 function extractTokenLikeValue(text, agent) {
-    const prefix = agent === 'claude' ? 'sk-ant-' : 'sk-';
+    const prefix = agent === 'claude' ? 'sk-ant-' : agent === 'pi' ? 'sk-' : 'sk-';
     const direct = text.match(new RegExp(`${prefix.replace(/-/g, '\\-')}[A-Za-z0-9_\\-]{8,}`));
     if (direct?.[0])
         return direct[0];
-    const keyMatch = text.match(/(?:api[_-]?key|auth[_-]?token|token)["'\s:=]+([A-Za-z0-9_\-.]{12,})/i);
+    const keyMatch = text.match(/(?:api[_-]?key|auth[_-]?token|token|dashscope)["'\s:=]+([A-Za-z0-9_\-.]{12,})/i);
     return keyMatch?.[1]?.trim();
 }
 function toSummary(input) {

package/dist/src/agents/manager.js

@@ -28,7 +28,14 @@ function managerInstructionsPath(workDir, sessionId) {
 }
 function buildStableManagerInstructions(workDir, managerSessionId) {
     const projectInstructions = readProjectAgentsMd(workDir);
-    const channelInstructions = getManagerRuntimeService()?.getManagerExternalChannelSystemPrompt(managerSessionId) ?? '';
+    const managerRuntime = getManagerRuntimeService();
+    const channelInstructions = managerRuntime?.getManagerExternalChannelSystemPrompt(managerSessionId) ?? '';
+    const workerDefaults = typeof managerRuntime?.getManagerWorkerDefaults === 'function'
+        ? managerRuntime.getManagerWorkerDefaults(managerSessionId)
+        : undefined;
+    const workerDefaultInstructions = workerDefaults?.agentType
+        ? `默认 worker Agent：${workerDefaults.agentType}${workerDefaults.modelId ? `\n默认 worker 模型：${workerDefaults.modelId}` : ''}。除非用户明确要求或任务明显需要其他 Agent/模型，创建 worker 时优先使用这个默认组合。`
+        : '';
     const sections = [
         '# Shennian Manager Instructions',
         'This file is generated by Shennian for a Manager Agent substrate session. Do not edit it by hand.',
@@ -36,6 +43,9 @@ function buildStableManagerInstructions(workDir, managerSessionId) {
             ? `## Project Instructions\n\n${projectInstructions}`
             : '',
         `## Manager Instructions\n\n${MANAGER_SYSTEM_PROMPT}`,
+        workerDefaultInstructions
+            ? `## Worker Defaults\n\n${workerDefaultInstructions}`
+            : '',
         channelInstructions
             ? `## External Message Channel Instructions\n\n${channelInstructions}`
             : '',

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

@@ -7,7 +7,7 @@ type ShellCommandSpec = {
     shell: 'bash' | 'powershell';
 };
 export declare function buildShellCommandSpec(command: string, platform?: NodeJS.Platform): ShellCommandSpec;
-export declare function createPiModel(modelId?: string): Model<'openai-completions'>;
+export declare function createPiModel(modelId?: string, overrides?: Partial<Pick<Model<'openai-completions'>, 'baseUrl' | 'provider' | 'compat'>>): Model<'openai-completions'>;
 export declare const SYSTEM_PROMPT = "\u4F60\u662F\u795E\u5FF5\u5185\u7F6E\u7F16\u7A0B\u52A9\u624B\uFF0C\u8FD0\u884C\u5728\u7528\u6237\u672C\u5730\u673A\u5668\u4E0A\u3002\n\u4F60\u53EF\u4EE5\u8BFB\u5199\u6587\u4EF6\u3001\u6267\u884C shell \u547D\u4EE4\u3001\u5E2E\u52A9\u7528\u6237\u5B8C\u6210\u7F16\u7A0B\u548C\u7CFB\u7EDF\u7BA1\u7406\u4EFB\u52A1\u3002\n\u5DE5\u4F5C\u76EE\u5F55\u5DF2\u8BBE\u7F6E\uFF0C\u64CD\u4F5C\u6587\u4EF6\u65F6\u4F7F\u7528\u76F8\u5BF9\u8DEF\u5F84\u6216\u7EDD\u5BF9\u8DEF\u5F84\u5747\u53EF\u3002\n\u5F53\u524D shell \u4F1A\u968F\u64CD\u4F5C\u7CFB\u7EDF\u9009\u62E9\uFF1AWindows \u4F7F\u7528 PowerShell\uFF0CmacOS/Linux \u4F7F\u7528 bash\u3002Windows \u4E0B\u9700\u8981\u771F\u5B9E curl \u65F6\u4F7F\u7528 curl.exe\uFF0C\u907F\u514D PowerShell \u7684 curl \u522B\u540D\u3002\n\u4FDD\u6301\u56DE\u590D\u7B80\u6D01\u3001\u51C6\u786E\uFF0C\u4E2D\u6587\u56DE\u590D\u3002";
 export declare const CONTEXT_TOKEN_THRESHOLD = 90000;
 export declare const KEEP_RECENT_MESSAGES = 6;

package/dist/src/agents/pi-context.js

@@ -17,18 +17,19 @@ export function buildShellCommandSpec(command, platform = process.platform) {
         shell: 'bash',
     };
 }
-export function createPiModel(modelId = PI_DEFAULT_MODEL_ID) {
+export function createPiModel(modelId = PI_DEFAULT_MODEL_ID, overrides = {}) {
     return {
         id: modelId,
         name: modelId,
         api: 'openai-completions',
-        provider: 'shennian-proxy',
-        baseUrl: '',
+        provider: overrides.provider ?? 'shennian-proxy',
+        baseUrl: overrides.baseUrl ?? '',
         reasoning: false,
         input: ['text', 'image'],
         cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
         contextWindow: 128000,
         maxTokens: 8192,
+        ...(overrides.compat ? { compat: overrides.compat } : {}),
     };
 }
 export const SYSTEM_PROMPT = `你是神念内置编程助手，运行在用户本地机器上。

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

@@ -12,6 +12,7 @@ export declare class PiAdapter extends AgentAdapter {
     private terminalState;
     private authToken;
     private proxyUrl;
+    private providerConfig;
     private sessionDir;
     private messagesPath;
     private snapshotPath;

package/dist/src/agents/pi.js

@@ -6,14 +6,17 @@ import path from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { Agent, streamProxy } from '@mariozechner/pi-agent-core';
+import { streamOpenAICompletions } from '@mariozechner/pi-ai/openai-completions';
 import { Type } from '@sinclair/typebox';
 import { AgentAdapter, registerAgent } from './adapter.js';
 import { buildExternalChannelInstructions } from './external-channel-instructions.js';
 import { loadConfig } from '../config/index.js';
+import { getManagedAgentProviderConfig } from './config-status.js';
 import { SERVERS } from '../region.js';
 import { buildRollingSummary, buildShellCommandSpec, cloneMessages, CONTEXT_TOKEN_THRESHOLD, createPiModel, estimateTokens, getSessionDir, KEEP_RECENT_MESSAGES, LEGACY_SUMMARY_FILENAME, longestCommonPrefixLength, MESSAGES_FILENAME, messagesToText, PI_DEFAULT_MODEL_ID, requestProxySummary, SNAPSHOT_FILENAME, SYSTEM_PROMPT, SUMMARY_FILENAME, } from './pi-context.js';
 export { buildShellCommandSpec } from './pi-context.js';
 const execFileAsync = promisify(execFile);
+const DASHSCOPE_COMPATIBLE_BASE_URL = 'https://dashscope.aliyuncs.com/compatible-mode/v1';
 // ── Local tools ───────────────────────────────────────────────────────────────
 function resolvePiToolPath(workDir, filePath) {
     return path.resolve(workDir, filePath);
@@ -26,6 +29,7 @@ async function executePiShellCommand(workDir, command, extraEnv, signal) {
         timeout: 30_000,
         signal,
         maxBuffer: 1024 * 1024,
+        windowsHide: true,
     });
     return { stdout, stderr, shell: spec.shell };
 }
@@ -239,6 +243,7 @@ export class PiAdapter extends AgentAdapter {
     terminalState = 'open';
     authToken = null;
     proxyUrl = null;
+    providerConfig;
     sessionDir = null;
     messagesPath = null;
     snapshotPath = null;
@@ -294,6 +299,11 @@ export class PiAdapter extends AgentAdapter {
         }
         this.authToken = authToken;
         this.proxyUrl = (config.serverUrl ?? SERVERS.cn.url).replace(/\/$/, '');
+        const managedProviderConfig = getManagedAgentProviderConfig('pi');
+        const dashscopeKey = config.apiKeys?.dashscope?.trim();
+        this.providerConfig = managedProviderConfig ?? (dashscopeKey
+            ? { agent: 'pi', token: dashscopeKey, updatedAt: '' }
+            : undefined);
         this.runId = randomUUID();
         this.seq = 0;
         this.emittedLengths.clear();
@@ -357,11 +367,30 @@ export class PiAdapter extends AgentAdapter {
                 model: createPiModel(),
                 tools,
             },
-            streamFn: (model, context, options) => streamProxy(model, context, {
-                ...options,
-                authToken: this.authToken,
-                proxyUrl: this.proxyUrl,
-            }),
+            streamFn: (model, context, options) => {
+                const providerConfig = this.providerConfig;
+                if (providerConfig?.token) {
+                    return streamOpenAICompletions(createPiModel(model.id, {
+                        provider: 'dashscope',
+                        baseUrl: providerConfig.baseUrl || DASHSCOPE_COMPATIBLE_BASE_URL,
+                        compat: {
+                            supportsDeveloperRole: false,
+                            supportsStore: false,
+                            supportsReasoningEffort: false,
+                            maxTokensField: 'max_tokens',
+                            thinkingFormat: 'qwen',
+                        },
+                    }), context, {
+                        ...options,
+                        apiKey: providerConfig.token,
+                    });
+                }
+                return streamProxy(model, context, {
+                    ...options,
+                    authToken: this.authToken,
+                    proxyUrl: this.proxyUrl,
+                });
+            },
             transformContext: (messages) => this.compressContext(messages),
         });
         this.agent = agent;

package/dist/src/commands/daemon.d.ts

@@ -1,3 +1,4 @@
+import { spawn } from 'node:child_process';
 import type { Command } from 'commander';
 export { buildWindowsLauncherCommand, buildWindowsScheduledTaskXml, buildWindowsStartupVbs, } from './daemon-windows.js';
 export declare function isSafeSnapshotEnvKey(key: string): boolean;
@@ -23,6 +24,11 @@ export type ServiceLaunchSpec = {
     args: string[];
     mode: ServiceLaunchMode;
 };
+export type DetachedLaunchSpec = {
+    command: string;
+    args: string[];
+    windowsVerbatimArguments?: boolean;
+};
 export declare function isEphemeralCliPath(candidate: string): boolean;
 export declare function resolveServiceLaunchSpec(input: {
     nodeExec: string;
@@ -39,6 +45,7 @@ export declare function recordStartedDaemon(childPid: number | undefined): void;
 export declare function getDaemonStatus(opts?: {
     cleanupStale?: boolean;
 }): DaemonStatus;
+export declare function buildDaemonSpawnOptions(launch: DetachedLaunchSpec, logFd: number, env?: NodeJS.ProcessEnv): Parameters<typeof spawn>[2];
 export declare function captureEnvForService(): Record<string, string>;
 /**
  * Save current env vars so the daemon can load them at startup.

package/dist/src/commands/daemon.js

@@ -160,6 +160,7 @@ function inferDaemonLauncherFromProcess(pid) {
             encoding: 'utf-8',
             stdio: ['ignore', 'pipe', 'ignore'],
             timeout: 1000,
+            windowsHide: true,
         }).replace(/\\/g, '/');
         if (command.includes('/node_modules/shennian/') ||
             command.includes('/bin/shennian') ||
@@ -229,6 +230,7 @@ function findCommandPath(binary) {
         const output = execSync(command, {
             stdio: ['ignore', 'pipe', 'pipe'],
             encoding: 'utf-8',
+            windowsHide: true,
         });
         const first = output
             .split(/\r?\n/)
@@ -257,7 +259,7 @@ function resolveCurrentServiceLaunchSpec() {
 }
 function removeLegacyWindowsTask() {
     try {
-        execSync(`schtasks /delete /tn "${WINDOWS_TASK_NAME}" /f`, { stdio: 'pipe' });
+        execSync(`schtasks /delete /tn "${WINDOWS_TASK_NAME}" /f`, { stdio: 'pipe', windowsHide: true });
     }
     catch {
         // Ignore missing legacy Task Scheduler entries during migration.
@@ -295,6 +297,15 @@ function buildDetachedLaunchSpec(spec) {
         args: spec.args,
     };
 }
+export function buildDaemonSpawnOptions(launch, logFd, env = process.env) {
+    return {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        env,
+        windowsHide: true,
+        ...(launch.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
+    };
+}
 function installWindowsScheduledTask() {
     const launch = resolveCurrentServiceLaunchSpec();
     fs.writeFileSync(WINDOWS_STARTUP_CMD, buildWindowsLauncherCommand(launch, LOG_FILE));
@@ -310,8 +321,9 @@ function installWindowsScheduledTask() {
     try {
         execSync(`schtasks /create /tn "${WINDOWS_TASK_NAME}" /xml "${WINDOWS_TASK_XML}" /f`, {
             stdio: 'pipe',
+            windowsHide: true,
         });
-        execSync(`schtasks /run /tn "${WINDOWS_TASK_NAME}"`, { stdio: 'pipe' });
+        execSync(`schtasks /run /tn "${WINDOWS_TASK_NAME}"`, { stdio: 'pipe', windowsHide: true });
         return true;
     }
     catch {
@@ -423,12 +435,7 @@ export function startDaemonProcess(opts = {}) {
     }
     const logFd = fs.openSync(LOG_FILE, 'a');
     const launch = buildDetachedLaunchSpec(resolveCurrentServiceLaunchSpec());
-    const child = spawn(launch.command, launch.args, {
-        detached: true,
-        stdio: ['ignore', logFd, logFd],
-        env: process.env,
-        ...(launch.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
-    });
+    const child = spawn(launch.command, launch.args, buildDaemonSpawnOptions(launch, logFd));
     child.unref();
     fs.closeSync(logFd);
     recordStartedDaemon(child.pid);
@@ -456,12 +463,12 @@ export function installService() {
             fs.writeFileSync(LAUNCHD_PLIST, buildPlist());
             try {
                 // Unload first (ignore errors), then reload - this starts the service immediately
-                execSync(`launchctl unload "${LAUNCHD_PLIST}" 2>/dev/null; launchctl load -w "${LAUNCHD_PLIST}"`, { stdio: 'pipe' });
+                execSync(`launchctl unload "${LAUNCHD_PLIST}" 2>/dev/null; launchctl load -w "${LAUNCHD_PLIST}"`, { stdio: 'pipe', windowsHide: true });
                 return true; // launchd started it; caller must NOT also call startDaemonProcess
             }
             catch {
                 try {
-                    execSync(`launchctl load -w "${LAUNCHD_PLIST}"`, { stdio: 'pipe' });
+                    execSync(`launchctl load -w "${LAUNCHD_PLIST}"`, { stdio: 'pipe', windowsHide: true });
                     return true;
                 }
                 catch {
@@ -477,6 +484,7 @@ export function installService() {
             try {
                 execSync('systemctl --user daemon-reload && systemctl --user enable shennian', {
                     stdio: 'pipe',
+                    windowsHide: true,
                 });
             }
             catch {
@@ -486,13 +494,13 @@ export function installService() {
             // Enable linger so the user systemd session (and thus this service) persists
             // across reboots even without an active login session.
             try {
-                execSync(`loginctl enable-linger ${os.userInfo().username}`, { stdio: 'pipe' });
+                execSync(`loginctl enable-linger ${os.userInfo().username}`, { stdio: 'pipe', windowsHide: true });
             }
             catch {
                 // loginctl is unavailable on some distros/containers; auto-start still works after login.
             }
             try {
-                execSync('systemctl --user restart shennian', { stdio: 'pipe' });
+                execSync('systemctl --user restart shennian', { stdio: 'pipe', windowsHide: true });
                 return true;
             }
             catch {
@@ -572,7 +580,7 @@ async function disableRemoteAccess(opts = {}) {
         case 'darwin': {
             if (fs.existsSync(LAUNCHD_PLIST)) {
                 try {
-                    execSync(`launchctl unload -w "${LAUNCHD_PLIST}"`, { stdio: 'pipe' });
+                    execSync(`launchctl unload -w "${LAUNCHD_PLIST}"`, { stdio: 'pipe', windowsHide: true });
                 }
                 catch {
                     // The job may already be unloaded; keep the plist for future re-enable.
@@ -582,7 +590,7 @@ async function disableRemoteAccess(opts = {}) {
         }
         case 'linux': {
             try {
-                execSync('systemctl --user disable --now shennian', { stdio: 'pipe' });
+                execSync('systemctl --user disable --now shennian', { stdio: 'pipe', windowsHide: true });
             }
             catch {
                 // systemd user services may be unavailable; still stop the manual daemon.
@@ -591,13 +599,13 @@ async function disableRemoteAccess(opts = {}) {
         }
         case 'win32': {
             try {
-                execSync(`schtasks /change /tn "${WINDOWS_TASK_NAME}" /disable`, { stdio: 'pipe' });
+                execSync(`schtasks /change /tn "${WINDOWS_TASK_NAME}" /disable`, { stdio: 'pipe', windowsHide: true });
             }
             catch {
                 // Task may not exist yet; still stop the manual daemon.
             }
             try {
-                execSync(`schtasks /end /tn "${WINDOWS_TASK_NAME}"`, { stdio: 'pipe' });
+                execSync(`schtasks /end /tn "${WINDOWS_TASK_NAME}"`, { stdio: 'pipe', windowsHide: true });
             }
             catch {
                 // Task may not be running.
@@ -722,7 +730,7 @@ function daemonLogs(opts) {
     try {
         const out = execSync(os.platform() === 'win32'
             ? `powershell Get-Content -Tail ${opts.lines} "${LOG_FILE}"`
-            : `tail -n ${opts.lines} "${LOG_FILE}"`, { encoding: 'utf-8' });
+            : `tail -n ${opts.lines} "${LOG_FILE}"`, { encoding: 'utf-8', windowsHide: true });
         process.stdout.write(out);
     }
     catch {
@@ -737,7 +745,7 @@ async function daemonUninstall() {
         case 'darwin': {
             if (fs.existsSync(LAUNCHD_PLIST)) {
                 try {
-                    execSync(`launchctl unload -w "${LAUNCHD_PLIST}"`, { stdio: 'pipe' });
+                    execSync(`launchctl unload -w "${LAUNCHD_PLIST}"`, { stdio: 'pipe', windowsHide: true });
                 }
                 catch {
                     // Continue removing the plist even if launchctl already forgot about it.
@@ -749,7 +757,7 @@ async function daemonUninstall() {
         }
         case 'linux': {
             try {
-                execSync('systemctl --user disable --now shennian', { stdio: 'pipe' });
+                execSync('systemctl --user disable --now shennian', { stdio: 'pipe', windowsHide: true });
             }
             catch {
                 // Service may already be absent or systemd user services may be unavailable.
@@ -757,7 +765,7 @@ async function daemonUninstall() {
             if (fs.existsSync(SYSTEMD_UNIT)) {
                 fs.unlinkSync(SYSTEMD_UNIT);
                 try {
-                    execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+                    execSync('systemctl --user daemon-reload', { stdio: 'pipe', windowsHide: true });
                 }
                 catch {
                     // Ignore reload errors during cleanup.

package/dist/src/commands/external-attachments.d.ts

@@ -0,0 +1,9 @@
+export type ExternalAttachmentKind = 'image' | 'video' | 'file';
+export type ExternalAttachmentPayload = {
+    kind: ExternalAttachmentKind;
+    name: string;
+    mimeType: string;
+    size: number;
+    dataBase64: string;
+};
+export declare function readExternalAttachment(filePath: string, kind: ExternalAttachmentKind): ExternalAttachmentPayload;

package/dist/src/commands/external-attachments.js

@@ -0,0 +1,52 @@
+// @arch docs/features/wecom-managed-channel.md
+// @test src/__tests__/external-command.test.ts
+import fs from 'node:fs';
+import path from 'node:path';
+const MIME_BY_EXT = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.mp4': 'video/mp4',
+    '.mov': 'video/quicktime',
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.csv': 'text/csv',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.xls': 'application/vnd.ms-excel',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.ppt': 'application/vnd.ms-powerpoint',
+    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    '.zip': 'application/zip',
+};
+const MAX_EXTERNAL_ATTACHMENT_BYTES = Number(process.env.SHENNIAN_EXTERNAL_ATTACHMENT_MAX_BYTES || 50 * 1024 * 1024);
+function inferMimeType(filePath, kind) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (MIME_BY_EXT[ext])
+        return MIME_BY_EXT[ext];
+    if (kind === 'image')
+        return 'image/jpeg';
+    if (kind === 'video')
+        return 'video/mp4';
+    return 'application/octet-stream';
+}
+export function readExternalAttachment(filePath, kind) {
+    const absolutePath = path.resolve(filePath);
+    const stat = fs.statSync(absolutePath);
+    if (!stat.isFile())
+        throw new Error(`Attachment is not a file: ${absolutePath}`);
+    if (stat.size > MAX_EXTERNAL_ATTACHMENT_BYTES) {
+        throw new Error(`Attachment is too large: ${stat.size} bytes. Max: ${MAX_EXTERNAL_ATTACHMENT_BYTES} bytes.`);
+    }
+    const buffer = fs.readFileSync(absolutePath);
+    return {
+        kind,
+        name: path.basename(absolutePath),
+        mimeType: inferMimeType(absolutePath, kind),
+        size: buffer.byteLength,
+        dataBase64: buffer.toString('base64'),
+    };
+}