@vectorplane/ctrl-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VectorPlane
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,167 @@
+# VectorPlane Ctrl CLI
+
+`vectorplane-ctrl-cli` é o CLI oficial do ecossistema **VectorPlane**, nome comercial do backend `conductor-edge-ia`.
+
+O repositório analisado posiciona o produto como uma control plane de contexto para engenharia com IA: memória remota por workspace, snapshots consolidados, governança, sessões de agentes, jobs e operação edge. Este CLI segue exatamente essa lógica. Ele não é um utilitário genérico de sync; ele é a porta local para autenticação, coleta de contexto da máquina, análise de workspace e envio seguro de snapshots para o plano de controle.
+
+## Relação com `conductor-edge-ia`
+
+O backend atual define alguns conceitos centrais que este CLI preserva:
+
+- `workspace` como unidade primária de contexto
+- `snapshot` consolidado como envelope principal de estado
+- `agent session` e `clientInstanceId` como base de observabilidade e coordenação
+- `control plane` como camada acima de clientes locais, MCP e REST
+- preocupação explícita com governança, rastreabilidade, serialização consistente e isolamento
+
+O `vp` foi desenhado para se encaixar nesse vocabulário e servir como cliente local premium do VectorPlane.
+
+## Evolução planejada
+
+O roadmap do CLI foi documentado em [`docs/evolution-phases.md`](./docs/evolution-phases.md), alinhado às fases já visíveis no `conductor-edge-ia`:
+
+- `Foundation`
+- `Coordination`
+- `Governed Sync`
+- `Enterprise Control Surface`
+
+## Instalação
+
+```bash
+npm install
+npm run build
+npm install -g .
+```
+
+Instalação via npm público:
+
+```bash
+npm install -g @vectorplane/ctrl-cli
+```
+
+## Uso local
+
+```bash
+vp login
+vp status
+vp sync
+vp whoami
+vp doctor
+vp workspace current
+```
+
+## Comandos
+
+### `vp login`
+
+- inicia callback local em `http://127.0.0.1:4217/callback`
+- gera `state` seguro
+- abre o navegador para autenticação
+- troca `code` por tokens via API
+- persiste a sessão em `~/.vectorplane/session.json`
+
+### `vp sync`
+
+- exige sessão ativa
+- coleta contexto de máquina, runtime, workspace e git
+- gera snapshot estruturado e hash estável
+- faz deduplicação por hash
+- persiste snapshot localmente
+- envia para `POST https://api.vectorplane.io/sync`
+- enfileira localmente quando a API falha
+
+### `vp status`
+
+- informa estado da sessão local
+- mostra perfil ativo
+- mostra workspace ativo e binding local
+- mostra diretório atual
+- mostra machine ID persistido
+- mostra branch git, fila local, sessão de agente e última sincronização quando disponíveis
+
+### Comandos adicionais já implementados
+
+- `vp whoami`
+  - consulta a identidade atual via API
+- `vp doctor`
+  - verifica diretório local, git, health, ready e autenticação
+- `vp config`
+  - lista, cria e troca perfis
+  - lê e altera configurações principais
+- `vp workspace`
+  - consulta o workspace atual
+  - faz binding manual
+  - tenta resolver por repositório remoto
+- `vp session`
+  - faz check-in, heartbeat e check-out de sessão de agente
+- `vp context`
+  - carrega `context`, `snapshot` ou `delivery-context`
+- `vp bootstrap`
+  - lê `agent-setup` e guidance de bootstrap do workspace
+- `vp event send`
+  - envia ou enfileira eventos operacionais
+
+## Persistência local
+
+Arquivos usados:
+
+- `~/.vectorplane/config.json`
+- `~/.vectorplane/session.json`
+- `~/.vectorplane/device.json`
+- `~/.vectorplane/state.json`
+- `~/.vectorplane/queue.json`
+- `~/.vectorplane/workspaces.json`
+- `~/.vectorplane/snapshots/`
+
+## Segurança
+
+- tokens nunca são impressos no terminal
+- tokens nunca são enviados por query string
+- o callback aceita apenas `code` e `state`
+- `state` é validado obrigatoriamente
+- logs evitam payloads sensíveis e mascaram chaves delicadas
+- remotes git são sanitizados antes de entrarem no snapshot
+
+## Desenvolvimento
+
+```bash
+npm run check
+npm run build
+npm start -- status
+```
+
+## Publicação npm
+
+O pacote foi preparado para publicação pública como `@vectorplane/ctrl-cli`.
+
+Checklist local:
+
+```bash
+npm run release:check
+```
+
+Publicação:
+
+```bash
+npm login
+npm publish --access public
+```
+
+Notas de empacotamento:
+
+- o tarball publica apenas `bin/`, `dist/`, `README.md` e `LICENSE`
+- `src/`, `docs/`, `.git/`, `node_modules/`, `package-lock.json` e arquivos locais não entram no pacote
+- tokens, sessão local e dados de `~/.vectorplane/` não fazem parte do publish
+
+## Integração aplicada
+
+O fluxo web e backend do CLI foi alinhado ao ecossistema real:
+
+- dashboard com rota `/cli/login`
+- emissão autenticada de código por `POST /auth/cli/code`
+- troca de token por `POST /cli/token/exchange`
+- refresh por `POST /cli/token/refresh`
+- resolução e leitura de workspace via rotas `cli/workspace/*`
+- `POST /sync` e `POST /events` no mesmo envelope oficial do worker
+
+O cliente agora faz unwrapping do envelope `{ success, data, requestId }` usado pelo `conductor-edge-ia`, em vez de assumir respostas cruas.

package/bin/vp.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import("../dist/index.js")
+  .then(({ runCli }) => runCli(process.argv.slice(2)))
+  .then((exitCode) => {
+    process.exitCode = typeof exitCode === "number" ? exitCode : 0;
+  })
+  .catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`VectorPlane: ${message}`);
+    process.exitCode = 1;
+  });

package/dist/commands/bootstrap.d.ts

@@ -0,0 +1 @@
+export declare function runBootstrapCommand(cliVersion: string, args: string[]): Promise<number>;

package/dist/commands/bootstrap.js

@@ -0,0 +1,40 @@
+import { getStringOption, parseArgs } from "../core/cli.js";
+import { ensureSessionAvailable, getProfileState } from "../core/config.js";
+import { collectGitContext } from "../core/git.js";
+import { collectMachineContext, collectRuntimeContext } from "../core/machine.js";
+import { loadRuntimeStatus } from "../core/runtime.js";
+import { ensureFreshSession, resolveWorkspaceSlug } from "../core/session.js";
+import { VectorPlaneApiClient } from "../core/api.js";
+import { getBoundWorkspace, resolveWorkspaceRoot } from "../core/workspace-binding.js";
+import { ValidationError } from "../core/errors.js";
+export async function runBootstrapCommand(cliVersion, args) {
+    const parsed = parseArgs(args);
+    const runtime = await loadRuntimeStatus();
+    const session = await ensureSessionAvailable(runtime.profile.name);
+    const [git, machine, runtimeContext] = await Promise.all([
+        collectGitContext(process.cwd()),
+        collectMachineContext(runtime.device, runtime.config),
+        collectRuntimeContext(cliVersion, "bootstrap", process.argv.slice(2)),
+    ]);
+    const apiClient = new VectorPlaneApiClient(runtime.profile.apiBaseUrl, runtime.config.requestTimeoutMs, runtime.logger);
+    const freshSession = await ensureFreshSession({
+        profileName: runtime.profile.name,
+        session,
+        machine,
+        runtime: runtimeContext,
+        device: runtime.device,
+        apiClient,
+        logger: runtime.logger,
+    });
+    const rootPath = resolveWorkspaceRoot(process.cwd(), git);
+    const boundWorkspace = await getBoundWorkspace(rootPath);
+    const profileState = getProfileState(runtime.state, runtime.profile.name);
+    const workspace = resolveWorkspaceSlug(runtime.profile, freshSession, getStringOption(parsed, "workspace"), boundWorkspace, profileState.lastWorkspace);
+    if (!workspace) {
+        throw new ValidationError("Nenhum workspace resolvido para bootstrap.");
+    }
+    const payload = await apiClient.getAgentSetup(freshSession.accessToken, workspace);
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return 0;
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist/commands/config.d.ts

@@ -0,0 +1 @@
+export declare function runConfigCommand(args: string[]): Promise<number>;

package/dist/commands/config.js

@@ -0,0 +1,96 @@
+import { getStringOption, parseArgs, requirePositional } from "../core/cli.js";
+import { getActiveProfile, loadConfig, saveConfig, setActiveProfile, upsertProfile } from "../core/config.js";
+import { ValidationError } from "../core/errors.js";
+function setProfileField(profile, key, value) {
+    switch (key) {
+        case "apiBaseUrl":
+            return { ...profile, apiBaseUrl: value };
+        case "appBaseUrl":
+            return { ...profile, appBaseUrl: value };
+        case "workspace":
+            return { ...profile, workspace: value };
+        case "orgId":
+            return { ...profile, orgId: value };
+        case "environment":
+            return { ...profile, environment: value };
+        default:
+            throw new ValidationError(`Campo de perfil não suportado: ${key}`);
+    }
+}
+export async function runConfigCommand(args) {
+    const parsed = parseArgs(args);
+    const [subcommand, ...rest] = parsed.positionals;
+    const config = await loadConfig();
+    if (!subcommand) {
+        process.stdout.write(JSON.stringify(config, null, 2));
+        process.stdout.write("\n");
+        return 0;
+    }
+    if (subcommand === "profile") {
+        const action = rest[0];
+        if (!action || action === "list") {
+            for (const profile of Object.values(config.profiles)) {
+                process.stdout.write(`${profile.name}${config.activeProfile === profile.name ? " *" : ""}\n`);
+            }
+            return 0;
+        }
+        if (action === "create") {
+            const name = rest[1];
+            if (!name) {
+                throw new ValidationError("Informe o nome do perfil.");
+            }
+            await upsertProfile(name, { name });
+            process.stdout.write(`Perfil criado: ${name}\n`);
+            return 0;
+        }
+        if (action === "use") {
+            const name = rest[1];
+            if (!name) {
+                throw new ValidationError("Informe o nome do perfil.");
+            }
+            await setActiveProfile(name);
+            process.stdout.write(`Perfil ativo: ${name}\n`);
+            return 0;
+        }
+    }
+    if (subcommand === "get") {
+        const key = requirePositional({ ...parsed, positionals: rest }, 0, "Informe a chave a ser lida.");
+        const active = getActiveProfile(config);
+        switch (key) {
+            case "debug":
+                process.stdout.write(String(config.debug));
+                break;
+            case "telemetryEnabled":
+                process.stdout.write(String(config.telemetryEnabled));
+                break;
+            default:
+                process.stdout.write(String(active[key] ?? ""));
+                break;
+        }
+        process.stdout.write("\n");
+        return 0;
+    }
+    if (subcommand === "set") {
+        const key = rest[0];
+        const value = rest[1];
+        if (!key || value === undefined) {
+            throw new ValidationError("Uso: vp config set <chave> <valor>");
+        }
+        if (key === "debug" || key === "telemetryEnabled") {
+            const next = { ...config, [key]: ["1", "true", "yes", "on"].includes(value.toLowerCase()) };
+            await saveConfig(next);
+            process.stdout.write(`Configuração atualizada: ${key}\n`);
+            return 0;
+        }
+        const profileName = getStringOption(parsed, "profile") ?? config.activeProfile;
+        const current = config.profiles[profileName];
+        if (!current) {
+            throw new ValidationError(`Perfil ${profileName} não existe.`);
+        }
+        await upsertProfile(profileName, setProfileField(current, key, value));
+        process.stdout.write(`Perfil ${profileName} atualizado: ${key}\n`);
+        return 0;
+    }
+    throw new ValidationError("Subcomando de config não suportado.");
+}
+//# sourceMappingURL=config.js.map

package/dist/commands/context.d.ts

@@ -0,0 +1 @@
+export declare function runContextCommand(cliVersion: string, args: string[]): Promise<number>;

package/dist/commands/context.js

@@ -0,0 +1,46 @@
+import { getBooleanOption, getStringOption, parseArgs } from "../core/cli.js";
+import { ensureSessionAvailable, getProfileState } from "../core/config.js";
+import { collectGitContext } from "../core/git.js";
+import { collectMachineContext, collectRuntimeContext } from "../core/machine.js";
+import { loadRuntimeStatus } from "../core/runtime.js";
+import { ensureFreshSession, resolveWorkspaceSlug } from "../core/session.js";
+import { VectorPlaneApiClient } from "../core/api.js";
+import { getBoundWorkspace, resolveWorkspaceRoot } from "../core/workspace-binding.js";
+import { ValidationError } from "../core/errors.js";
+export async function runContextCommand(cliVersion, args) {
+    const parsed = parseArgs(args);
+    const delivery = getBooleanOption(parsed, "delivery");
+    const snapshot = getBooleanOption(parsed, "snapshot");
+    const runtime = await loadRuntimeStatus();
+    const session = await ensureSessionAvailable(runtime.profile.name);
+    const [git, machine, runtimeContext] = await Promise.all([
+        collectGitContext(process.cwd()),
+        collectMachineContext(runtime.device, runtime.config),
+        collectRuntimeContext(cliVersion, "context", process.argv.slice(2)),
+    ]);
+    const apiClient = new VectorPlaneApiClient(runtime.profile.apiBaseUrl, runtime.config.requestTimeoutMs, runtime.logger);
+    const freshSession = await ensureFreshSession({
+        profileName: runtime.profile.name,
+        session,
+        machine,
+        runtime: runtimeContext,
+        device: runtime.device,
+        apiClient,
+        logger: runtime.logger,
+    });
+    const rootPath = resolveWorkspaceRoot(process.cwd(), git);
+    const boundWorkspace = await getBoundWorkspace(rootPath);
+    const profileState = getProfileState(runtime.state, runtime.profile.name);
+    const workspace = resolveWorkspaceSlug(runtime.profile, freshSession, getStringOption(parsed, "workspace"), boundWorkspace, profileState.lastWorkspace);
+    if (!workspace) {
+        throw new ValidationError("Nenhum workspace resolvido para carregar contexto.");
+    }
+    const payload = delivery
+        ? await apiClient.getWorkspaceDeliveryContext(freshSession.accessToken, workspace)
+        : snapshot
+            ? await apiClient.getWorkspaceSnapshot(freshSession.accessToken, workspace)
+            : await apiClient.getWorkspaceContext(freshSession.accessToken, workspace);
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+    return 0;
+}
+//# sourceMappingURL=context.js.map

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function runDoctorCommand(cliVersion: string): Promise<number>;

package/dist/commands/doctor.js

@@ -0,0 +1,69 @@
+import { access } from "node:fs/promises";
+import { constants as fsConstants } from "node:fs";
+import { configDirectoryExists, ensureSessionAvailable, getConfigDirectoryPath } from "../core/config.js";
+import { collectGitContext } from "../core/git.js";
+import { collectMachineContext, collectRuntimeContext } from "../core/machine.js";
+import { loadRuntimeStatus } from "../core/runtime.js";
+import { ensureFreshSession } from "../core/session.js";
+import { VectorPlaneApiClient } from "../core/api.js";
+async function writable(filePath) {
+    try {
+        await access(filePath, fsConstants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function printCheck(label, ok, details) {
+    process.stdout.write(`${ok ? "OK" : "FAIL"} ${label}: ${details}\n`);
+}
+export async function runDoctorCommand(cliVersion) {
+    const runtime = await loadRuntimeStatus();
+    const configDirectory = await getConfigDirectoryPath();
+    const [hasConfigDir, git, canWriteConfig] = await Promise.all([
+        configDirectoryExists(),
+        collectGitContext(process.cwd()),
+        writable(configDirectory),
+    ]);
+    printCheck("config_dir", hasConfigDir, configDirectory);
+    printCheck("config_dir_writable", canWriteConfig, canWriteConfig ? "gravável" : "sem permissão de escrita");
+    printCheck("git", git.isRepository, git.isRepository ? (git.rootPath ?? process.cwd()) : "repositório não detectado");
+    printCheck("node", true, process.version);
+    const apiClient = new VectorPlaneApiClient(runtime.profile.apiBaseUrl, runtime.config.requestTimeoutMs, runtime.logger);
+    try {
+        const health = await apiClient.getHealth();
+        printCheck("api_health", true, JSON.stringify(health));
+    }
+    catch (error) {
+        printCheck("api_health", false, error instanceof Error ? error.message : String(error));
+    }
+    try {
+        const ready = await apiClient.getReady();
+        printCheck("api_ready", true, JSON.stringify(ready));
+    }
+    catch (error) {
+        printCheck("api_ready", false, error instanceof Error ? error.message : String(error));
+    }
+    try {
+        const session = await ensureSessionAvailable(runtime.profile.name);
+        const machine = await collectMachineContext(runtime.device, runtime.config);
+        const runtimeContext = await collectRuntimeContext(cliVersion, "doctor", process.argv.slice(2));
+        const freshSession = await ensureFreshSession({
+            profileName: runtime.profile.name,
+            session,
+            machine,
+            runtime: runtimeContext,
+            device: runtime.device,
+            apiClient,
+            logger: runtime.logger,
+        });
+        const me = await apiClient.getCurrentUser(freshSession.accessToken);
+        printCheck("auth_me", true, `${me.type}:${me.id}`);
+    }
+    catch (error) {
+        printCheck("auth_me", false, error instanceof Error ? error.message : String(error));
+    }
+    return 0;
+}
+//# sourceMappingURL=doctor.js.map

package/dist/commands/event.d.ts

@@ -0,0 +1 @@
+export declare function runEventCommand(cliVersion: string, args: string[]): Promise<number>;

package/dist/commands/event.js

@@ -0,0 +1,65 @@
+import { getStringOption, parseArgs, parseJsonOption, requirePositional } from "../core/cli.js";
+import { ensureSessionAvailable, getProfileState } from "../core/config.js";
+import { collectGitContext } from "../core/git.js";
+import { collectMachineContext, collectRuntimeContext } from "../core/machine.js";
+import { loadRuntimeStatus } from "../core/runtime.js";
+import { ensureFreshSession, resolveWorkspaceSlug } from "../core/session.js";
+import { VectorPlaneApiClient } from "../core/api.js";
+import { queueEvent } from "../core/queue.js";
+import { getBoundWorkspace, resolveWorkspaceRoot } from "../core/workspace-binding.js";
+import { ValidationError } from "../core/errors.js";
+export async function runEventCommand(cliVersion, args) {
+    const parsed = parseArgs(args);
+    const [subcommand] = parsed.positionals;
+    if (!subcommand || subcommand !== "send") {
+        throw new ValidationError("Uso: vp event send <nome> [--payload '{...}']");
+    }
+    const eventName = requirePositional(parsed, 1, "Informe o nome do evento.");
+    const payloadObject = parseJsonOption(getStringOption(parsed, "payload"));
+    const runtime = await loadRuntimeStatus();
+    const session = await ensureSessionAvailable(runtime.profile.name);
+    const [git, machine, runtimeContext] = await Promise.all([
+        collectGitContext(process.cwd()),
+        collectMachineContext(runtime.device, runtime.config),
+        collectRuntimeContext(cliVersion, "event", process.argv.slice(2)),
+    ]);
+    const apiClient = new VectorPlaneApiClient(runtime.profile.apiBaseUrl, runtime.config.requestTimeoutMs, runtime.logger);
+    const freshSession = await ensureFreshSession({
+        profileName: runtime.profile.name,
+        session,
+        machine,
+        runtime: runtimeContext,
+        device: runtime.device,
+        apiClient,
+        logger: runtime.logger,
+    });
+    const rootPath = resolveWorkspaceRoot(process.cwd(), git);
+    const boundWorkspace = await getBoundWorkspace(rootPath);
+    const profileState = getProfileState(runtime.state, runtime.profile.name);
+    const workspace = resolveWorkspaceSlug(runtime.profile, freshSession, getStringOption(parsed, "workspace"), boundWorkspace, profileState.lastWorkspace);
+    if (!workspace) {
+        throw new ValidationError("Nenhum workspace resolvido para o evento.");
+    }
+    const eventPayload = {
+        workspace,
+        event: eventName,
+        payload: {
+            ...payloadObject,
+            branch: git.branch,
+            commitHash: git.commitHash,
+            rootPath,
+        },
+        sent_at: new Date().toISOString(),
+    };
+    try {
+        await apiClient.sendEvent(freshSession.accessToken, eventPayload);
+        runtime.logger.success("evento enviado.");
+        return 0;
+    }
+    catch (error) {
+        await queueEvent(runtime.profile.name, eventPayload, error);
+        runtime.logger.warn("API indisponível no momento. O evento foi enfileirado localmente.");
+        return 0;
+    }
+}
+//# sourceMappingURL=event.js.map

package/dist/commands/login.d.ts

@@ -0,0 +1 @@
+export declare function runLoginCommand(cliVersion: string, args: string[]): Promise<number>;

package/dist/commands/login.js

@@ -0,0 +1,39 @@
+import { getStringOption, parseArgs } from "../core/cli.js";
+import { runLoginFlow } from "../core/auth.js";
+import { saveSession, setActiveProfile, updateProfileState, upsertProfile } from "../core/config.js";
+import { collectMachineContext, collectRuntimeContext } from "../core/machine.js";
+import { loadRuntimeStatus } from "../core/runtime.js";
+import { VectorPlaneApiClient } from "../core/api.js";
+export async function runLoginCommand(cliVersion, args) {
+    const parsed = parseArgs(args);
+    const requestedProfile = getStringOption(parsed, "profile");
+    if (requestedProfile) {
+        await upsertProfile(requestedProfile, { name: requestedProfile });
+        await setActiveProfile(requestedProfile);
+    }
+    const runtime = await loadRuntimeStatus();
+    const machine = await collectMachineContext(runtime.device, runtime.config);
+    const runtimeContext = await collectRuntimeContext(cliVersion, "login", process.argv.slice(2));
+    const apiClient = new VectorPlaneApiClient(runtime.profile.apiBaseUrl, runtime.config.requestTimeoutMs, runtime.logger);
+    const session = await runLoginFlow({
+        config: runtime.config,
+        profile: runtime.profile,
+        machine,
+        runtime: runtimeContext,
+        device: runtime.device,
+        apiClient,
+        logger: runtime.logger,
+    });
+    await saveSession(session, runtime.profile.name);
+    await upsertProfile(runtime.profile.name, { workspace: session.workspace });
+    await updateProfileState(runtime.profile.name, {
+        lastCommand: "login",
+        lastWorkspace: session.workspace,
+        lastError: null,
+    });
+    runtime.logger.success("login realizado com sucesso.");
+    process.stdout.write(`Perfil: ${runtime.profile.name}\n`);
+    process.stdout.write(`Workspace ativo: ${session.workspace}\n`);
+    return 0;
+}
+//# sourceMappingURL=login.js.map

package/dist/commands/session.d.ts

@@ -0,0 +1 @@
+export declare function runSessionCommand(cliVersion: string, args: string[]): Promise<number>;