@vectorplane/ctrl-cli 0.1.11 → 0.1.13

package/dist/core/api.js

@@ -144,6 +144,21 @@ export class VectorPlaneApiClient {
             },
         }, this.timeoutMs, this.logger);
     }
+    async getWorkspaceSnapshotDiff(accessToken, workspaceId, params) {
+        const url = new URL(`${this.apiBaseUrl}/workspace/${workspaceId}/snapshot/diff`);
+        if (params.from) {
+            url.searchParams.set("from", params.from);
+        }
+        if (params.to) {
+            url.searchParams.set("to", params.to);
+        }
+        return requestJson(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
     async getWorkspaceDeliveryContext(accessToken, workspaceId) {
         return requestJson(`${this.apiBaseUrl}/cli/workspace/${workspaceId}/delivery-context`, {
             method: "GET",
@@ -152,6 +167,26 @@ export class VectorPlaneApiClient {
             },
         }, this.timeoutMs, this.logger);
     }
+    async getWorkspaceDeliveryContextSemantic(accessToken, workspaceId, params) {
+        const url = new URL(`${this.apiBaseUrl}/cli/workspace/${workspaceId}/delivery-context`);
+        url.searchParams.set("mode", "semantic");
+        url.searchParams.set("query", params.query);
+        if (params.type) {
+            url.searchParams.set("type", params.type);
+        }
+        if (params.authority) {
+            url.searchParams.set("authority", params.authority);
+        }
+        if (typeof params.limit === "number") {
+            url.searchParams.set("limit", String(params.limit));
+        }
+        return requestJson(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
     async getAgentSetup(accessToken, workspaceId) {
         return requestJson(`${this.apiBaseUrl}/cli/workspace/${workspaceId}/agent-setup`, {
             method: "GET",
@@ -160,6 +195,51 @@ export class VectorPlaneApiClient {
             },
         }, this.timeoutMs, this.logger);
     }
+    async listWorkspacePolicyRules(accessToken, workspaceRef) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/policy-rules`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async createWorkspacePolicyRule(accessToken, workspaceRef, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/policy-rules`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async updateWorkspacePolicyRule(accessToken, workspaceRef, ruleId, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/policy-rules/${ruleId}`, {
+            method: "PUT",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async listWorkspaceWebhooks(accessToken, workspaceRef) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/webhooks`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async createWorkspaceWebhook(accessToken, workspaceRef, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/webhooks`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async deleteWorkspaceWebhook(accessToken, workspaceRef, webhookId) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/webhooks/${webhookId}`, {
+            method: "DELETE",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
     async listMemoryDrafts(accessToken, workspaceRef, status) {
         const url = new URL(`${this.apiBaseUrl}/cli/workspace/${workspaceRef}/memory-drafts`);
         if (status) {
@@ -179,6 +259,159 @@ export class VectorPlaneApiClient {
             body: JSON.stringify(payload),
         }, this.timeoutMs, this.logger);
     }
+    async searchWorkspaceMemory(accessToken, workspaceRef, params) {
+        const url = new URL(`${this.apiBaseUrl}/cli/workspace/${workspaceRef}/memory/search`);
+        url.searchParams.set("q", params.query);
+        if (params.type) {
+            url.searchParams.set("type", params.type);
+        }
+        if (params.authority) {
+            url.searchParams.set("authority", params.authority);
+        }
+        if (typeof params.limit === "number") {
+            url.searchParams.set("limit", String(params.limit));
+        }
+        return requestJson(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async listTasks(accessToken, workspaceRef) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async createTask(accessToken, workspaceRef, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async listTaskTemplates(accessToken) {
+        return requestJson(`${this.apiBaseUrl}/admin/task-templates`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async getTask(accessToken, workspaceRef, taskId) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/${taskId}`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async listClaimableTaskSteps(accessToken, workspaceRef, filters) {
+        const url = new URL(`${this.apiBaseUrl}/cli/workspace/${workspaceRef}/tasks/claimable`);
+        if (filters?.capability) {
+            url.searchParams.set("capability", filters.capability);
+        }
+        if (filters?.agentName) {
+            url.searchParams.set("agent_name", filters.agentName);
+        }
+        return requestJson(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async claimTaskStep(accessToken, workspaceRef, taskId, stepId, payload) {
+        return requestJson(`${this.apiBaseUrl}/cli/workspace/${workspaceRef}/tasks/${taskId}/steps/${stepId}/claim`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload ?? {}),
+        }, this.timeoutMs, this.logger);
+    }
+    async delegateTask(accessToken, workspaceRef, taskId, stepId, toAgentId, reason) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/${taskId}/delegate`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify({ stepId, toAgentId, reason }),
+        }, this.timeoutMs, this.logger);
+    }
+    async callbackTaskStep(accessToken, workspaceRef, taskId, stepId, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/${taskId}/steps/${stepId}/callback`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async getTaskHandoff(accessToken, workspaceRef, taskId) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/${taskId}/handoff`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async getTaskObservability(accessToken, workspaceRef, taskId) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/${taskId}/observability`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async getWorkspaceTaskObservability(accessToken, workspaceRef) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/observability`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async approveTask(accessToken, workspaceRef, taskId, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/tasks/${taskId}/approve`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async listAgentRegistry(accessToken) {
+        return requestJson(`${this.apiBaseUrl}/admin/agent-registry`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async createRegistryAgent(accessToken, payload) {
+        return requestJson(`${this.apiBaseUrl}/admin/agent-registry`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async updateRegistryAgent(accessToken, agentId, payload) {
+        return requestJson(`${this.apiBaseUrl}/admin/agent-registry/${agentId}`, {
+            method: "PUT",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async deactivateRegistryAgent(accessToken, agentId) {
+        return requestJson(`${this.apiBaseUrl}/admin/agent-registry/${agentId}/deactivate`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+        }, this.timeoutMs, this.logger);
+    }
+    async getWorkspaceHealth(accessToken, workspaceRef) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/health`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
     async checkInAgent(accessToken, payload) {
         return requestJson(`${this.apiBaseUrl}/cli/workspace/${payload.workspaceId}/agents/check-in`, {
             method: "POST",
@@ -226,5 +459,79 @@ export class VectorPlaneApiClient {
             method: "GET",
         }, this.timeoutMs, this.logger);
     }
+    async streamWorkspaceEvents(accessToken, workspaceRef, params) {
+        const url = new URL(`${this.apiBaseUrl}/workspace/${workspaceRef}/events/stream`);
+        if (params.taskId) {
+            url.searchParams.set("task_id", params.taskId);
+        }
+        if (params.types && params.types.length > 0) {
+            url.searchParams.set("types", params.types.join(","));
+        }
+        this.logger.debug("http_stream_open", { url: url.toString() });
+        const response = await fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+                "Accept": "text/event-stream",
+            },
+            signal: params.signal,
+        });
+        if (!response.ok || !response.body) {
+            const body = await parseBody(response);
+            const message = typeof body === "string" ? body : `HTTP ${response.status}`;
+            throw new ApiError(message, response.status, body);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const emitFrame = (frame) => {
+            const lines = frame.split("\n");
+            let eventName = "message";
+            const dataLines = [];
+            for (const line of lines) {
+                if (line.startsWith("event:")) {
+                    eventName = line.slice(6).trim();
+                    continue;
+                }
+                if (line.startsWith("data:")) {
+                    dataLines.push(line.slice(5).trim());
+                }
+            }
+            if (dataLines.length === 0) {
+                return;
+            }
+            try {
+                const payload = JSON.parse(dataLines.join("\n"));
+                params.onEvent({
+                    type: eventName,
+                    workspaceId: payload.workspaceId,
+                    taskId: payload.taskId ?? null,
+                    stepId: payload.stepId ?? null,
+                    timestamp: payload.timestamp,
+                    summary: payload.summary ?? null,
+                });
+            }
+            catch (error) {
+                this.logger.debug("http_stream_frame_ignored", {
+                    reason: error instanceof Error ? error.message : "invalid_json",
+                    eventName,
+                });
+            }
+        };
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let separatorIndex = buffer.indexOf("\n\n");
+            while (separatorIndex >= 0) {
+                const frame = buffer.slice(0, separatorIndex);
+                buffer = buffer.slice(separatorIndex + 2);
+                emitFrame(frame);
+                separatorIndex = buffer.indexOf("\n\n");
+            }
+        }
+    }
 }
 //# sourceMappingURL=api.js.map

package/dist/core/init-workspace.d.ts

@@ -0,0 +1,29 @@
+import type { SupportedAgent } from "./agent-runtime-detection.js";
+import type { CliConfig, CliProfileConfig } from "../types/config.js";
+import type { DeviceIdentity } from "../types/machine.js";
+import type { Logger } from "./logger.js";
+export declare function buildInitLoginArgs(params: {
+    manual: boolean;
+    noBrowser: boolean;
+    profile?: string;
+}): Promise<string[]>;
+export declare function runInitWorkspaceUseCase(params: {
+    cliVersion: string;
+    commandArgs: string[];
+    runtime: {
+        profile: CliProfileConfig;
+        config: CliConfig;
+        device: DeviceIdentity;
+        logger: Logger;
+    };
+    force: boolean;
+    explicitWorkspace?: string;
+    requestedAgent?: SupportedAgent;
+    ensureLoggedIn: () => Promise<void>;
+}): Promise<{
+    workspace: string;
+    agent: SupportedAgent;
+    confidence: string;
+    templatePath: string;
+    fileStatus: string;
+}>;

package/dist/core/init-workspace.js

@@ -0,0 +1,73 @@
+import { ensureSessionAvailable, loadSession, upsertProfile } from "./config.js";
+import { collectGitContext } from "./git.js";
+import { collectMachineContext, collectRuntimeContext } from "./machine.js";
+import { VectorPlaneApiClient } from "./api.js";
+import { ensureFreshSession } from "./session.js";
+import { ensureAgentSetupCurrent } from "./agent-setup.js";
+import { resolveWorkspaceRoot } from "./workspace-binding.js";
+import { resolveAuthorizedWorkspace } from "./workspace-resolution.js";
+export async function buildInitLoginArgs(params) {
+    const loginArgs = [];
+    if (params.manual) {
+        loginArgs.push("--manual");
+    }
+    if (params.noBrowser) {
+        loginArgs.push("--no-browser");
+    }
+    if (params.profile) {
+        loginArgs.push("--profile", params.profile);
+    }
+    return loginArgs;
+}
+export async function runInitWorkspaceUseCase(params) {
+    let session = await loadSession(params.runtime.profile.name);
+    if (!session) {
+        params.runtime.logger.info("sessão local ausente, iniciando login...");
+        await params.ensureLoggedIn();
+        session = await ensureSessionAvailable(params.runtime.profile.name);
+    }
+    const [git, machine, runtimeContext] = await Promise.all([
+        collectGitContext(process.cwd()),
+        collectMachineContext(params.runtime.device, params.runtime.config),
+        collectRuntimeContext(params.cliVersion, "init", params.commandArgs),
+    ]);
+    const apiClient = new VectorPlaneApiClient(params.runtime.profile.apiBaseUrl, params.runtime.config.requestTimeoutMs, params.runtime.logger);
+    const freshSession = await ensureFreshSession({
+        profileName: params.runtime.profile.name,
+        session,
+        machine,
+        runtime: runtimeContext,
+        device: params.runtime.device,
+        apiClient,
+        logger: params.runtime.logger,
+    });
+    const rootPath = resolveWorkspaceRoot(process.cwd(), git);
+    const workspace = await resolveAuthorizedWorkspace({
+        apiClient,
+        accessToken: freshSession.accessToken,
+        git,
+        explicitWorkspace: params.explicitWorkspace,
+        profile: params.runtime.profile,
+        session: freshSession,
+    });
+    const result = await ensureAgentSetupCurrent({
+        rootPath,
+        workspace,
+        repoUrl: git.remoteOrigin,
+        source: git.remoteOrigin ? "api-resolve" : "manual",
+        accessToken: freshSession.accessToken,
+        apiClient,
+        logger: params.runtime.logger,
+        explicitAgent: params.requestedAgent,
+        force: params.force,
+    });
+    await upsertProfile(params.runtime.profile.name, { workspace });
+    return {
+        workspace,
+        agent: result.agent,
+        confidence: result.confidence,
+        templatePath: result.templatePath,
+        fileStatus: result.fileStatus,
+    };
+}
+//# sourceMappingURL=init-workspace.js.map

package/dist/core/runtime-agent-setup.d.ts

@@ -0,0 +1,18 @@
+import type { VectorPlaneApiClient } from "./api.js";
+import type { Logger } from "./logger.js";
+import type { AuthSession } from "../types/auth.js";
+import type { GitContext } from "../types/workspace.js";
+export declare function ensureRuntimeAgentSetup(params: {
+    rootPath: string;
+    workspace: string;
+    git: GitContext;
+    session: AuthSession;
+    apiClient: VectorPlaneApiClient;
+    logger: Logger;
+}): Promise<{
+    agent: import("./agent-runtime-detection.js").SupportedAgent;
+    templatePath: string;
+    fileStatus: "created" | "updated" | "unchanged";
+    changed: boolean;
+    confidence: import("./agent-runtime-detection.js").DetectionConfidence;
+}>;

package/dist/core/runtime-agent-setup.js

@@ -0,0 +1,13 @@
+import { ensureAgentSetupCurrent } from "./agent-setup.js";
+export async function ensureRuntimeAgentSetup(params) {
+    return ensureAgentSetupCurrent({
+        rootPath: params.rootPath,
+        workspace: params.workspace,
+        repoUrl: params.git.remoteOrigin,
+        source: params.git.remoteOrigin ? "api-resolve" : "manual",
+        accessToken: params.session.accessToken,
+        apiClient: params.apiClient,
+        logger: params.logger,
+    });
+}
+//# sourceMappingURL=runtime-agent-setup.js.map

package/dist/core/task-runner.d.ts

@@ -0,0 +1,16 @@
+export interface LocalTaskExecutionInput {
+    execution: Record<string, unknown> | null | undefined;
+    workspaceRoot: string;
+    workspaceRef: string;
+    taskId: string;
+    stepId: string;
+    capability: string;
+}
+export declare function executeLocalTaskStep(input: LocalTaskExecutionInput): Promise<{
+    command: string;
+    args: string[];
+    cwd: string;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;

package/dist/core/task-runner.js

@@ -0,0 +1,62 @@
+import { spawn } from "node:child_process";
+import { ValidationError } from "./errors.js";
+function interpolate(value, context) {
+    return value.replace(/\{([a-zA-Z0-9_]+)\}/g, (_, key) => context[key] ?? "");
+}
+function asStringArray(value) {
+    return Array.isArray(value) ? value.map((item) => String(item)) : [];
+}
+export async function executeLocalTaskStep(input) {
+    const execution = input.execution ?? {};
+    const type = typeof execution.type === "string" ? execution.type : "command";
+    if (type !== "command") {
+        throw new ValidationError("A execução local do step exige `metadata.execution.type = command`.");
+    }
+    const rawCommand = typeof execution.command === "string" ? execution.command.trim() : "";
+    if (!rawCommand) {
+        throw new ValidationError("A execução local do step exige `metadata.execution.command`.");
+    }
+    const context = {
+        workspaceRoot: input.workspaceRoot,
+        workspace: input.workspaceRef,
+        taskId: input.taskId,
+        stepId: input.stepId,
+        capability: input.capability,
+    };
+    const command = interpolate(rawCommand, context);
+    const args = asStringArray(execution.args).map((item) => interpolate(item, context));
+    const cwd = typeof execution.cwd === "string" && execution.cwd.trim()
+        ? interpolate(execution.cwd, context)
+        : input.workspaceRoot;
+    const envOverrides = execution.env && typeof execution.env === "object"
+        ? Object.fromEntries(Object.entries(execution.env).map(([key, value]) => [key, interpolate(String(value), context)]))
+        : {};
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            env: { ...process.env, ...envOverrides },
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: false,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", reject);
+        child.on("close", (exitCode) => {
+            resolve({
+                command,
+                args,
+                cwd,
+                exitCode: exitCode ?? 1,
+                stdout: stdout.trim(),
+                stderr: stderr.trim(),
+            });
+        });
+    });
+}
+//# sourceMappingURL=task-runner.js.map

package/dist/index.js

@@ -10,9 +10,11 @@ import { runEventCommand } from "./commands/event.js";
 import { runInitCommand } from "./commands/init.js";
 import { runLoginCommand } from "./commands/login.js";
 import { runLogoutCommand } from "./commands/logout.js";
+import { runRegistryCommand } from "./commands/registry.js";
 import { runSessionCommand } from "./commands/session.js";
 import { runStatusCommand } from "./commands/status.js";
 import { runSyncCommand } from "./commands/sync.js";
+import { runTaskCommand } from "./commands/task.js";
 import { runWhoAmICommand } from "./commands/whoami.js";
 import { runWorkspaceCommand } from "./commands/workspace.js";
 import { CLIError } from "./core/errors.js";
@@ -33,11 +35,13 @@ function printHelp() {
     process.stdout.write("  logout\n");
     process.stdout.write("  sync [--force]\n");
     process.stdout.write("  status\n");
+    process.stdout.write("  task <run|templates|list|inspect|watch|claim|execute|daemon|approve|reject|delegate|step-update|handoff|observability|health>\n");
+    process.stdout.write("  registry <list|register|update|deactivate>\n");
     process.stdout.write("  whoami\n");
     process.stdout.write("  doctor\n");
     process.stdout.write("  draft <create|list>\n");
     process.stdout.write("  config <profile|get|set>\n");
-    process.stdout.write("  workspace <current|use|resolve|clear>\n");
+    process.stdout.write("  workspace <current|use|resolve|clear|policy|webhook>\n");
     process.stdout.write("  session <check-in|heartbeat|check-out>\n");
     process.stdout.write("  context [--snapshot|--delivery]\n");
     process.stdout.write("  bootstrap\n");
@@ -60,8 +64,12 @@ export async function runCli(args) {
                 return runSyncCommand(cliVersion, rest);
             case "logout":
                 return runLogoutCommand();
+            case "registry":
+                return runRegistryCommand(rest);
             case "status":
                 return runStatusCommand();
+            case "task":
+                return runTaskCommand(cliVersion, rest);
             case "whoami":
                 return runWhoAmICommand(cliVersion);
             case "doctor":