@alisio/core 0.1.0-alpha.16 → 0.1.0-alpha.18

package/dist/agents/active.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Pure logic for the ACTIVE (main-session) agent: the built-in catalog, user/plugin
+ * contributions, resolution and the per-run options an agent implies. No terminal or pi-tui
+ * imports here — the Picker and status-line rendering live in each surface (e.g. the TUI shell).
+ *
+ * The active agent drives the MAIN session (its `instructions` are appended per run and an
+ * agent-specific `model` is offered on selection). This is deliberately separate from the
+ * delegated child-session agents of the subagents plugin: a subagent definition becomes a main
+ * agent only when it is marked main-capable (`mode: primary|all`), which the subagents plugin
+ * publishes for the host to read.
+ */
+export interface ActiveAgent {
+    /** Stable id, also the persisted `agents.active` value. */
+    id: string;
+    name: string;
+    description: string;
+    /** System prompt appended to the main session's instructions on every run. */
+    instructions?: string;
+    /** Optional default model selector (`provider/model` or an unambiguous model id). */
+    model?: string;
+    /** Read-only agents run with write/process/external tools disabled and approvals off. */
+    readOnly?: boolean;
+    /** Product built-ins are shown as built-in and never shadowed by contributed definitions. */
+    source: "builtin" | "user" | "plugin";
+}
+export declare const DEFAULT_AGENT_ID = "build";
+/** Product built-ins. `build` keeps the CURRENT behavior exactly: no added persona, full power. */
+export declare const BUILTIN_AGENTS: ActiveAgent[];
+export interface MainCapableAgentRecord {
+    name: string;
+    description: string;
+    prompt: string;
+    model?: string;
+    readOnly?: boolean;
+    source: string;
+    path?: string;
+}
+/** Maps a main-capable definition published by the subagents plugin to an active agent. */
+export declare function mainAgentFromRecord(record: MainCapableAgentRecord): ActiveAgent;
+/** Builds the selectable catalog from the subagents plugin's published state (best-effort). */
+export declare function agentCatalogFromState(untrusted: unknown): ActiveAgent[];
+/**
+ * The full selectable catalog: built-ins first, then contributed main-capable definitions.
+ * A contributed definition may never shadow a built-in id; later duplicates of a contributed id
+ * are dropped (the subagents plugin already resolved precedence by its own discovery order).
+ */
+export declare function activeAgentCatalog(contributions?: ActiveAgent[]): ActiveAgent[];
+/** Resolves the persisted agent id; unknown ids fall back to the built-in default (`build`). */
+export declare function resolveActiveAgent(agents: ActiveAgent[], id: string | undefined): ActiveAgent;
+/** The run options an active agent implies. An undefined agent yields the current behavior. */
+export declare function agentRunOptions(agent: ActiveAgent | undefined): {
+    instructions?: string;
+    policy?: {
+        write: false;
+        process: false;
+        external: false;
+    };
+    approvals?: false;
+};
+export interface AgentPickerItem {
+    value: string;
+    label: string;
+    description: string;
+}
+/** Picker rows for `/agents`: name with (current), built-in/default and read-only markers. */
+export declare function agentPickerItems(agents: ActiveAgent[], activeId: string): AgentPickerItem[];

package/dist/agents/active.js

@@ -0,0 +1,113 @@
+export const DEFAULT_AGENT_ID = "build";
+const PLAN_INSTRUCTIONS = `You are the "plan" agent: a read-only planning assistant for this main session.
+
+Your job is analysis and planning only. Investigate the repository with read-only tools
+(list_files, search_text, read_file, git_status, git_diff) and return a concrete, ordered plan:
+files to change, functions to touch, risks and verification steps. You may run context and
+inspection tools that do not modify anything.
+
+You never edit, write or delete files, and you never start processes that change the workspace
+or the network. If a task requires changes, hand back a precise plan (and the exact commands)
+instead of making them.`;
+/** Product built-ins. `build` keeps the CURRENT behavior exactly: no added persona, full power. */
+export const BUILTIN_AGENTS = [
+    {
+        id: DEFAULT_AGENT_ID,
+        name: "build",
+        description: "Default full-power agent: edits code and files, runs processes and verifies its work through the normal permission flow.",
+        source: "builtin",
+    },
+    {
+        id: "plan",
+        name: "plan",
+        description: "Read-only planning agent: analyzes the codebase and returns an implementation plan without modifying anything.",
+        instructions: PLAN_INSTRUCTIONS,
+        readOnly: true,
+        source: "builtin",
+    },
+];
+/** Maps a main-capable definition published by the subagents plugin to an active agent. */
+export function mainAgentFromRecord(record) {
+    const source = String(record.source ?? "");
+    return {
+        id: record.name,
+        name: record.name,
+        description: record.description,
+        ...(record.prompt ? { instructions: record.prompt } : {}),
+        ...(record.model ? { model: record.model } : {}),
+        ...(record.readOnly ? { readOnly: true } : {}),
+        ...(source.startsWith("plugin:")
+            ? { source: "plugin" }
+            : { source: "user" }),
+    };
+}
+/** Builds the selectable catalog from the subagents plugin's published state (best-effort). */
+export function agentCatalogFromState(untrusted) {
+    if (!Array.isArray(untrusted))
+        return activeAgentCatalog([]);
+    const records = untrusted.filter((entry) => !!entry &&
+        typeof entry === "object" &&
+        typeof entry.name === "string" &&
+        typeof entry.description === "string" &&
+        entry.description.length > 0 &&
+        typeof entry.prompt === "string");
+    return activeAgentCatalog(records.map(mainAgentFromRecord));
+}
+/**
+ * The full selectable catalog: built-ins first, then contributed main-capable definitions.
+ * A contributed definition may never shadow a built-in id; later duplicates of a contributed id
+ * are dropped (the subagents plugin already resolved precedence by its own discovery order).
+ */
+export function activeAgentCatalog(contributions = []) {
+    const seen = new Set();
+    const out = [];
+    for (const agent of [...BUILTIN_AGENTS, ...contributions]) {
+        if (seen.has(agent.id))
+            continue;
+        seen.add(agent.id);
+        out.push(agent);
+    }
+    return out;
+}
+/** Resolves the persisted agent id; unknown ids fall back to the built-in default (`build`). */
+export function resolveActiveAgent(agents, id) {
+    const found = id ? agents.find((a) => a.id === id) : undefined;
+    if (found)
+        return found;
+    return agents.find((a) => a.id === DEFAULT_AGENT_ID) ?? agents[0] ?? BUILTIN_AGENTS[0];
+}
+/** The run options an active agent implies. An undefined agent yields the current behavior. */
+export function agentRunOptions(agent) {
+    if (!agent)
+        return {};
+    return {
+        ...(agent.instructions ? { instructions: agent.instructions } : {}),
+        ...(agent.readOnly
+            ? {
+                policy: { write: false, process: false, external: false },
+                approvals: false,
+            }
+            : {}),
+    };
+}
+/** Picker rows for `/agents`: name with (current), built-in/default and read-only markers. */
+export function agentPickerItems(agents, activeId) {
+    return agents.map((agent) => ({
+        value: agent.id,
+        label: [
+            agent.name,
+            agent.id === activeId ? "(current)" : undefined,
+            agent.id === DEFAULT_AGENT_ID ? "(default)" : undefined,
+            agent.readOnly ? "read-only" : undefined,
+        ]
+            .filter(Boolean)
+            .join(" · "),
+        description: [
+            agent.description,
+            agent.model ? `default model: ${agent.model}` : undefined,
+            agent.instructions ? "injects its system prompt from the next prompt" : undefined,
+        ]
+            .filter(Boolean)
+            .join(" · "),
+    }));
+}

package/dist/application.d.ts

@@ -10,6 +10,8 @@ import { ActiveProvider, ProviderRegistry } from "./providers/registry.ts";
 import { ProviderSettingsStore } from "./providers/settings.ts";
 import { ProjectContext } from "./resources/context.ts";
 import { Skills } from "./resources/skills.ts";
+import { type ExternalDirectoryHandler, PathAccess } from "./runtime/access.ts";
+import { BlobStore } from "./runtime/blobs.ts";
 import { SQLiteStore } from "./runtime/store.ts";
 export interface AppOptions {
     cwd?: string;
@@ -23,6 +25,8 @@ export interface AppOptions {
     allowMcp?: boolean;
     readOnly?: boolean;
     allowAgents?: boolean;
+    /** Extra directories the tools may touch outside the workspace (per-run `--add-dir`). */
+    addDirs?: string[];
     noHerdr?: boolean;
     model?: string;
     baseURL?: string;
@@ -45,6 +49,11 @@ export interface AppOptions {
     disablePlugins?: string[];
     /** Interactive approval for write/process tools; ignored in read-only mode. */
     approve?: ApprovalHandler;
+    /**
+     * Interactive approval for a tool path outside the workspace and every declared extra root,
+     * scoped to the containing directory (allow once / session / deny); ignored in read-only mode.
+     */
+    approveExternalDirectory?: ExternalDirectoryHandler;
 }
 export interface BuiltinContext {
     workspace: string;
@@ -95,6 +104,7 @@ export declare function enabledBuiltins(available: BuiltinPlugin[], config: Reco
 } & Record<string, unknown>>, disabled?: string[]): BuiltinPlugin[];
 export declare function createApplication(options?: AppOptions): Promise<{
     workspace: string;
+    pathAccess: PathAccess;
     config: import("./config.ts").LoadedConfig;
     prompts: {
         templates: Map<string, import("./index.ts").PromptTemplate>;
@@ -108,6 +118,8 @@ export declare function createApplication(options?: AppOptions): Promise<{
         template: import("./index.ts").PromptTemplate;
     } | undefined;
     store: SQLiteStore;
+    /** Uploaded attachment bytes; resolve a `BlobRef` with `blobs.attachment(ref)` before a run. */
+    blobs: BlobStore;
     registry: ToolRegistry;
     context: ProjectContext;
     skills: Skills;
@@ -150,13 +162,16 @@ export declare function createApplication(options?: AppOptions): Promise<{
      * (only when runtime permission was granted). Never includes credentials or command paths.
      */
     mcpStartupFailures(): string[];
-    /** Host-owned interactive consent boundary. Headless callers remain blocked unless flagged. */
+    /**
+     * Host-owned interactive consent boundary: the TUI and the web UI (`alisio serve`, after an
+     * explicit confirmation dialog) may grant. Headless callers remain blocked unless flagged.
+     */
     grantMcpRuntimePermission(request: {
-        source: "interactive-tui";
+        source: "interactive-tui" | "interactive-web";
         confirmed: boolean;
     }): "granted" | "not-granted" | "read-only";
     /** Persist global consent atomically, then grant runtime permission for this process. */
-    rememberGlobalMcpConsent(): Promise<void>;
+    rememberGlobalMcpConsent(source?: "interactive-tui" | "interactive-web"): Promise<void>;
     /**
      * Clear the persisted global consent atomically and drop the runtime permission (disconnecting
      * servers as cleanup does). An explicit this-run `--allow-mcp` flag keeps the grant alive.

package/dist/application.js

@@ -1,3 +1,4 @@
+import { realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { configFile, configHome, loadConfigWithProvenance, overridesSavedProviderProfile, setConfigValue, setGlobalMcpAllow, setMcpServerEnabled, setProjectPluginEnabled, setProjectSkillEnabled, stateHome, } from "./config.js";
@@ -13,6 +14,8 @@ import { ProviderSettingsStore } from "./providers/settings.js";
 import { ProjectContext } from "./resources/context.js";
 import { expandSlashPrompt, loadPromptTemplates, promptSources } from "./resources/prompts.js";
 import { Skills, skillRoots } from "./resources/skills.js";
+import { PathAccess } from "./runtime/access.js";
+import { BlobStore } from "./runtime/blobs.js";
 import { isPathSpec } from "./runtime/modules.js";
 import { findWorkspace } from "./runtime/paths.js";
 import { SQLiteStore } from "./runtime/store.js";
@@ -59,7 +62,28 @@ export async function createApplication(options = {}) {
     // a project value (see loadConfigWithProvenance), so a project cannot grant itself MCP consent.
     const mcpAllow = config.mcp.allow === true;
     let persistedMcpAllow = mcpAllow;
+    // Extra tool roots: config `additionalDirectories` (already canonicalized on load) plus per-run
+    // `--add-dir` (resolved against the current directory). Ignored entirely under --read-only, so
+    // the flag and the config key can never widen a locked session.
+    const addDirs = options.readOnly
+        ? []
+        : await Promise.all((options.addDirs ?? []).map((dir) => realpath(resolve(cwd, dir)).catch(() => resolve(cwd, dir))));
+    const pathAccess = new PathAccess({
+        workspace,
+        extraRoots: [...config.additionalDirectories, ...addDirs],
+        ...(options.approveExternalDirectory && !options.readOnly
+            ? { approve: options.approveExternalDirectory }
+            : {}),
+        readOnly: !!options.readOnly,
+    });
     const store = new SQLiteStore(options.db ?? join(stateHome(), "sessions.sqlite"));
+    // Content-addressed attachment bytes next to the session database (no I/O until `put`).
+    const blobs = new BlobStore({
+        root: options.db && options.db !== ":memory:"
+            ? join(dirname(options.db), "blobs")
+            : join(stateHome(), "blobs"),
+        db: store.db,
+    });
     const registry = new ToolRegistry(), skills = new Skills({ overrides: config.skillOverrides }), context = new ProjectContext(workspace, {
         globalDir: configHome(),
         cwd,
@@ -241,7 +265,7 @@ export async function createApplication(options = {}) {
         }, {
             config: config.websearch,
             resolveExtension: () => plugins.extensions.resolve("websearch"),
-        });
+        }, pathAccess);
         const { registerPluginInstallTool } = await import("./plugins/install.js");
         registerPluginInstallTool(registry, { readOnly: !!options.readOnly });
         if ((options.allowMcp || mcpAllow) && !options.readOnly)
@@ -503,6 +527,7 @@ export async function createApplication(options = {}) {
             extensions: plugins,
             contextWindow,
             ...(options.approve && !options.readOnly ? { approve: options.approve } : {}),
+            pathAccess,
             ...(config.websearch.provider === "native"
                 ? { nativeTools: [{ type: config.websearch.nativeToolType }] }
                 : {}),
@@ -515,6 +540,10 @@ export async function createApplication(options = {}) {
         // Child sessions (generic delegation service for plugins). Contexts are cached per workspace
         // so a child in a git worktree reads that worktree's AGENTS.md files.
         const contexts = new Map([[workspace, context]]);
+        // Startup reconciliation: runs left queued/running by a dead process become `interrupted`
+        // (runs of this process, e.g. another Application in a server, are kept). Child sessions are
+        // reconciled by `interruptStale()` in the ChildSessions constructor right below.
+        store.interruptRuns();
         plugins.setSessions(new ChildSessions({
             store,
             runner,
@@ -583,10 +612,13 @@ export async function createApplication(options = {}) {
         }
         return {
             workspace,
+            pathAccess,
             config,
             prompts,
             expandPrompt,
             store,
+            /** Uploaded attachment bytes; resolve a `BlobRef` with `blobs.attachment(ref)` before a run. */
+            blobs,
             registry,
             context,
             skills,
@@ -679,12 +711,15 @@ export async function createApplication(options = {}) {
             mcpStartupFailures() {
                 return [...mcpStartupFailures];
             },
-            /** Host-owned interactive consent boundary. Headless callers remain blocked unless flagged. */
+            /**
+             * Host-owned interactive consent boundary: the TUI and the web UI (`alisio serve`, after an
+             * explicit confirmation dialog) may grant. Headless callers remain blocked unless flagged.
+             */
             grantMcpRuntimePermission(request) {
                 if (!request.confirmed)
                     return mcpRuntimePermission;
-                if (request.source !== "interactive-tui")
-                    throw new Error("MCP runtime permission may only be granted by the interactive TUI");
+                if (request.source !== "interactive-tui" && request.source !== "interactive-web")
+                    throw new Error("MCP runtime permission may only be granted by an interactive UI");
                 if (options.readOnly)
                     throw new Error("MCP is unavailable under --read-only");
                 if (mcpRuntimePermission === "granted")
@@ -695,12 +730,12 @@ export async function createApplication(options = {}) {
                 return mcpRuntimePermission;
             },
             /** Persist global consent atomically, then grant runtime permission for this process. */
-            async rememberGlobalMcpConsent() {
+            async rememberGlobalMcpConsent(source = "interactive-tui") {
                 if (options.readOnly)
                     throw new Error("MCP is unavailable under --read-only");
                 await setGlobalMcpAllow({ allow: true });
                 persistedMcpAllow = true;
-                this.grantMcpRuntimePermission({ source: "interactive-tui", confirmed: true });
+                this.grantMcpRuntimePermission({ source, confirmed: true });
             },
             /**
              * Clear the persisted global consent atomically and drop the runtime permission (disconnecting
@@ -789,6 +824,9 @@ export async function createApplication(options = {}) {
                     case "tui.paddingX":
                         config.tui = { ...config.tui, paddingX: Number(value) };
                         break;
+                    case "tui.contentPaddingX":
+                        config.tui = { ...config.tui, contentPaddingX: Number(value) };
+                        break;
                     case "tui.skillSlashCommands":
                         config.tui = { ...config.tui, skillSlashCommands: value === true };
                         break;

package/dist/commands/builtins.d.ts

@@ -0,0 +1,10 @@
+import type { CommandDescriptor } from "@alisio/sdk";
+/** A built-in slash command: a descriptor without `source`/`owner` (always `builtin`). */
+export type BuiltinCommand = Omit<CommandDescriptor, "source" | "owner">;
+/**
+ * Built-in slash commands, in the order the TUI lists them. Names, aliases, descriptions and
+ * argument hints are the TUI's `COMMANDS` moved here as data (the TUI re-exports them).
+ * `execution: "core"` commands have a handler in `CommandCatalog.execute`; `surface` commands
+ * (clipboard, exit, settings/connect wizards, help, `/ask`) are handled by each UI.
+ */
+export declare const BUILTIN_COMMANDS: readonly BuiltinCommand[];

package/dist/commands/builtins.js

@@ -0,0 +1,115 @@
+const ALL = ["tui", "web", "api"];
+const TUI = ["tui"];
+const INTERACTIVE = ["tui", "web"];
+/**
+ * Built-in slash commands, in the order the TUI lists them. Names, aliases, descriptions and
+ * argument hints are the TUI's `COMMANDS` moved here as data (the TUI re-exports them).
+ * `execution: "core"` commands have a handler in `CommandCatalog.execute`; `surface` commands
+ * (clipboard, exit, settings/connect wizards, help, `/ask`) are handled by each UI.
+ */
+export const BUILTIN_COMMANDS = [
+    {
+        name: "help",
+        description: "Show commands and keys",
+        surfaces: INTERACTIVE,
+        execution: "surface",
+    },
+    {
+        name: "connect",
+        description: "Configure a provider and choose its active model",
+        surfaces: TUI,
+        execution: "surface",
+    },
+    {
+        name: "model",
+        description: "Switch provider and model",
+        aliases: ["models"],
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "compact",
+        description: "Summarize older history",
+        argumentHint: "[focus]",
+        surfaces: ALL,
+        execution: "core",
+    },
+    { name: "stats", description: "Session statistics", surfaces: ALL, execution: "core" },
+    {
+        name: "clear",
+        description: "Start a new session",
+        aliases: ["new"],
+        surfaces: ALL,
+        execution: "core",
+    },
+    { name: "sessions", description: "List recent sessions", surfaces: ALL, execution: "core" },
+    {
+        name: "resume",
+        description: "Resume a session by ID or prefix",
+        argumentHint: "<id>",
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "tools",
+        description: "List tools and permission state",
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "plugins",
+        description: "Browse and manage project plugins",
+        aliases: ["plugin"],
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "skills",
+        description: "Browse and manage effective skills",
+        aliases: ["skill"],
+        surfaces: ALL,
+        execution: "core",
+    },
+    { name: "mcp", description: "Browse and manage MCP servers", surfaces: ALL, execution: "core" },
+    {
+        name: "settings",
+        description: "Open the settings menu",
+        aliases: ["prefs"],
+        surfaces: TUI,
+        execution: "surface",
+    },
+    {
+        name: "copy",
+        description: "Copy the last assistant response to the clipboard",
+        surfaces: TUI,
+        execution: "surface",
+    },
+    {
+        name: "agents",
+        description: "List and switch the active agent (applies from the next prompt)",
+        argumentHint: "[<verb>]",
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "effort",
+        description: "Set the reasoning effort level for the active model",
+        argumentHint: "[level]",
+        surfaces: ALL,
+        execution: "core",
+    },
+    {
+        name: "ask",
+        description: "Ask the agent to turn your question into a multiple-choice ask_user_question",
+        argumentHint: "<question>",
+        surfaces: INTERACTIVE,
+        execution: "surface",
+    },
+    {
+        name: "exit",
+        description: "Exit Alisio",
+        aliases: ["quit"],
+        surfaces: TUI,
+        execution: "surface",
+    },
+];

package/dist/commands/catalog.d.ts

@@ -0,0 +1,83 @@
+/**
+ * One catalog of slash commands for every surface (TUI, web, API): built-ins, plugin commands,
+ * prompt templates and skills, with the pure core handlers of `execution: "core"` commands.
+ * The catalog reads its sources live from the host on each call, so plugin/template/skill
+ * changes show up without rebuilding it.
+ */
+import type { CommandDescriptor, ToolDefinition } from "@alisio/sdk";
+import type { PluginCatalogEntry } from "../application.ts";
+import type { SessionStore } from "../core/contracts.ts";
+import type { AgentRunner } from "../core/runner.ts";
+import type { McpServerInfo } from "../mcp/connector.ts";
+import type { PromptTemplate } from "../resources/prompts.ts";
+import type { SkillCatalogEntry } from "../resources/skills.ts";
+import { BUILTIN_COMMANDS, type BuiltinCommand } from "./builtins.ts";
+export { BUILTIN_COMMANDS, type BuiltinCommand };
+export type CommandSurface = CommandDescriptor["surfaces"][number];
+type PluginCommandHandler = (args: string, context?: {
+    sessionId?: string;
+}) => Promise<string>;
+/**
+ * What the catalog needs from an application. `createApplication()`'s result satisfies it; the
+ * optional members only enable the matching sources and handlers.
+ */
+export interface CommandHost {
+    workspace: string;
+    store: SessionStore;
+    runner: Pick<AgentRunner, "policy" | "approvals" | "compact" | "setModel">;
+    registry: {
+        list(): ToolDefinition[];
+    };
+    provider: {
+        id: string;
+    };
+    plugins?: {
+        commands: ReadonlyMap<string, PluginCommandHandler>;
+        commandInfo: ReadonlyMap<string, {
+            plugin: string;
+            description?: string;
+            argumentHint?: string;
+        }>;
+        pluginState?(plugin: string, key: string): unknown;
+    };
+    prompts?: {
+        templates: ReadonlyMap<string, PromptTemplate>;
+    };
+    skillCatalog?(): SkillCatalogEntry[];
+    pluginCatalog?(): PluginCatalogEntry[];
+    mcp?: {
+        list(): McpServerInfo[];
+    };
+    config?: {
+        agents: {
+            active?: string;
+            effort?: string;
+        };
+    };
+    updateSetting?(key: "agents.effort", value: unknown): Promise<string>;
+}
+export interface CommandExecutionContext {
+    sessionId: string;
+    signal?: AbortSignal;
+}
+export interface CommandResult {
+    /** Markdown for the user. */
+    text?: string;
+    /** `notice` is a short status line; `info` (default) a report. */
+    tone?: "info" | "notice";
+    /** The session the surface should switch to (`clear`/`new`, `resume`). */
+    sessionId?: string;
+    /** Structured result for programmatic callers (e.g. a `CompactionResult`). */
+    data?: unknown;
+}
+export declare class CommandCatalog {
+    private readonly host?;
+    constructor(host?: CommandHost | undefined);
+    private builtins;
+    /** Every descriptor (optionally for one surface). Precedence: builtin > plugin > prompt > skill. */
+    list(surface?: CommandSurface): CommandDescriptor[];
+    /** A command by name or alias (built-in names and aliases are case-insensitive). */
+    resolve(name: string): CommandDescriptor | undefined;
+    /** Runs an `execution: "core"` command. Surface commands and unknown names throw. */
+    execute(name: string, args: string, ctx: CommandExecutionContext): Promise<CommandResult>;
+}