@vectorplane/ctrl-cli 0.1.0

package/dist/commands/session.js

@@ -0,0 +1,110 @@
+import { getStringOption, parseArgs } from "../core/cli.js";
+import { ensureSessionAvailable, getProfileState, updateProfileState } 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 { deriveClientInstanceId, getBoundWorkspace, resolveWorkspaceRoot } from "../core/workspace-binding.js";
+import { ValidationError } from "../core/errors.js";
+export async function runSessionCommand(cliVersion, args) {
+    const parsed = parseArgs(args);
+    const [subcommand] = parsed.positionals;
+    if (!subcommand) {
+        throw new ValidationError("Uso: vp session <check-in|heartbeat|check-out>");
+    }
+    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, `session:${subcommand}`, 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 a sessão.");
+    }
+    const clientInstanceId = getStringOption(parsed, "client-instance-id") ?? deriveClientInstanceId(runtime.device.machineId, rootPath, git);
+    if (subcommand === "check-in") {
+        const response = await apiClient.checkInAgent(freshSession.accessToken, {
+            workspaceId: workspace,
+            agentName: getStringOption(parsed, "agent-name") ?? "vp-cli",
+            agentType: getStringOption(parsed, "agent-type") ?? "vp-cli",
+            clientName: getStringOption(parsed, "client-name") ?? "vectorplane-ctrl-cli",
+            clientInstanceId,
+            repoUrl: git.remoteOrigin ?? undefined,
+            branch: git.branch,
+            commitSha: git.commitHash,
+            metadata: {
+                source: "vp-cli",
+                rootPath,
+            },
+        });
+        const sessionId = String(response.id ?? response.sessionId ?? "");
+        await updateProfileState(runtime.profile.name, {
+            lastSessionId: sessionId || profileState.lastSessionId,
+            lastCommand: "session:check-in",
+            lastWorkspace: workspace,
+            lastError: null,
+        });
+        process.stdout.write(`Session ID: ${sessionId || "não retornado"}\n`);
+        process.stdout.write(`Client Instance ID: ${clientInstanceId}\n`);
+        return 0;
+    }
+    if (subcommand === "heartbeat") {
+        const sessionId = getStringOption(parsed, "session-id") ?? profileState.lastSessionId;
+        if (!sessionId) {
+            throw new ValidationError("Nenhuma sessão conhecida para heartbeat.");
+        }
+        await apiClient.heartbeatAgent(freshSession.accessToken, {
+            sessionId,
+            clientInstanceId,
+            branch: git.branch,
+            commitSha: git.commitHash,
+            metadata: {
+                source: "vp-cli",
+                rootPath,
+            },
+        });
+        await updateProfileState(runtime.profile.name, {
+            lastCommand: "session:heartbeat",
+            lastError: null,
+        });
+        process.stdout.write(`Heartbeat enviado para ${sessionId}\n`);
+        return 0;
+    }
+    if (subcommand === "check-out") {
+        const sessionId = getStringOption(parsed, "session-id") ?? profileState.lastSessionId;
+        if (!sessionId) {
+            throw new ValidationError("Nenhuma sessão conhecida para check-out.");
+        }
+        await apiClient.checkOutAgent(freshSession.accessToken, {
+            sessionId,
+            metadata: {
+                source: "vp-cli",
+            },
+        });
+        await updateProfileState(runtime.profile.name, {
+            lastSessionId: null,
+            lastCommand: "session:check-out",
+            lastError: null,
+        });
+        process.stdout.write(`Sessão encerrada: ${sessionId}\n`);
+        return 0;
+    }
+    throw new ValidationError("Subcomando de sessão não suportado.");
+}
+//# sourceMappingURL=session.js.map

package/dist/commands/status.d.ts

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

package/dist/commands/status.js

@@ -0,0 +1,46 @@
+import { configDirectoryExists, getConfigDirectoryPath, getProfileState, loadQueue, loadSession } from "../core/config.js";
+import { collectGitContext } from "../core/git.js";
+import { getBoundWorkspace } from "../core/workspace-binding.js";
+import { loadRuntimeStatus } from "../core/runtime.js";
+export async function runStatusCommand() {
+    const runtime = await loadRuntimeStatus();
+    const [hasConfigDir, session, git, configDirectory, queue] = await Promise.all([
+        configDirectoryExists(),
+        loadSession(runtime.profile.name),
+        collectGitContext(process.cwd()),
+        getConfigDirectoryPath(),
+        loadQueue(),
+    ]);
+    const rootPath = git.rootPath ?? process.cwd();
+    const boundWorkspace = await getBoundWorkspace(rootPath);
+    const profileState = getProfileState(runtime.state, runtime.profile.name);
+    const queuedItems = queue.items.filter((item) => item.profile === runtime.profile.name).length;
+    process.stdout.write(`Perfil: ${runtime.profile.name}\n`);
+    process.stdout.write(`Diretório: ${process.cwd()}\n`);
+    process.stdout.write(`Persistência local: ${configDirectory}\n`);
+    process.stdout.write(`Machine ID: ${runtime.device.machineId}\n`);
+    process.stdout.write(`Fila pendente: ${queuedItems}\n`);
+    if (!hasConfigDir || !session) {
+        runtime.logger.warn("sessão não encontrada.");
+        process.stdout.write(`Workspace vinculado: ${boundWorkspace ?? runtime.profile.workspace ?? "nenhum"}\n`);
+        return 0;
+    }
+    runtime.logger.success("sessão ativa.");
+    process.stdout.write(`Workspace: ${session.workspace}\n`);
+    process.stdout.write(`Workspace vinculado: ${boundWorkspace ?? runtime.profile.workspace ?? "nenhum"}\n`);
+    process.stdout.write(`Sessão de agente: ${profileState.lastSessionId ?? "nenhuma"}\n`);
+    process.stdout.write(`Expira em: ${session.expiresAt}\n`);
+    if (git.branch) {
+        process.stdout.write(`Branch: ${git.branch}\n`);
+    }
+    process.stdout.write(`Última sincronização: ${profileState.lastSyncAt ?? "nunca"}\n`);
+    process.stdout.write(`Status do último sync: ${profileState.lastSyncStatus ?? "desconhecido"}\n`);
+    if (profileState.lastSnapshotPath) {
+        process.stdout.write(`Último snapshot local: ${profileState.lastSnapshotPath}\n`);
+    }
+    if (profileState.lastError) {
+        process.stdout.write(`Último erro: ${profileState.lastError}\n`);
+    }
+    return 0;
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/sync.d.ts

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

package/dist/commands/sync.js

@@ -0,0 +1,108 @@
+import { getBooleanOption, getStringOption, parseArgs } from "../core/cli.js";
+import { ensureSessionAvailable, getProfileState, persistSnapshot, updateProfileState } from "../core/config.js";
+import { collectGitContext } from "../core/git.js";
+import { collectMachineContext, collectRuntimeContext } from "../core/machine.js";
+import { flushQueue, queueSync } from "../core/queue.js";
+import { loadRuntimeStatus } from "../core/runtime.js";
+import { buildSnapshotEnvelope } from "../core/serializer.js";
+import { ensureFreshSession, resolveWorkspaceSlug } from "../core/session.js";
+import { VectorPlaneApiClient } from "../core/api.js";
+import { collectWorkspaceContext } from "../core/workspace.js";
+import { getBoundWorkspace } from "../core/workspace-binding.js";
+import { ValidationError } from "../core/errors.js";
+export async function runSyncCommand(cliVersion, args) {
+    const parsed = parseArgs(args);
+    const force = getBooleanOption(parsed, "force");
+    const explicitWorkspace = getStringOption(parsed, "workspace");
+    const runtime = await loadRuntimeStatus();
+    const session = await ensureSessionAvailable(runtime.profile.name);
+    const apiClient = new VectorPlaneApiClient(runtime.profile.apiBaseUrl, runtime.config.requestTimeoutMs, runtime.logger);
+    runtime.logger.info("analisando workspace...");
+    const [machine, runtimeContext, git] = await Promise.all([
+        collectMachineContext(runtime.device, runtime.config),
+        collectRuntimeContext(cliVersion, "sync", process.argv.slice(2)),
+        collectGitContext(process.cwd()),
+    ]);
+    const freshSession = await ensureFreshSession({
+        profileName: runtime.profile.name,
+        session,
+        machine,
+        runtime: runtimeContext,
+        device: runtime.device,
+        apiClient,
+        logger: runtime.logger,
+    });
+    const workspaceRoot = git.rootPath ?? process.cwd();
+    const boundWorkspace = await getBoundWorkspace(workspaceRoot);
+    const profileState = getProfileState(runtime.state, runtime.profile.name);
+    const workspaceSlug = resolveWorkspaceSlug(runtime.profile, freshSession, explicitWorkspace, boundWorkspace, profileState.lastWorkspace);
+    if (!workspaceSlug) {
+        throw new ValidationError("Nenhum workspace ativo foi resolvido. Use `vp workspace use <workspace>` ou `vp login`.");
+    }
+    const workspace = await collectWorkspaceContext(process.cwd(), git);
+    runtime.logger.info("consolidando contexto...");
+    const timestamp = new Date().toISOString();
+    const snapshot = {
+        machine,
+        runtime: runtimeContext,
+        workspace,
+        git,
+        command: {
+            name: "sync",
+            startedAt: timestamp,
+            cwd: process.cwd(),
+        },
+        timestamp,
+    };
+    const { hash } = buildSnapshotEnvelope(snapshot);
+    if (!force && profileState.lastSyncHash === hash) {
+        runtime.logger.info("nenhuma mudança material detectada desde o último sync.");
+        return 0;
+    }
+    const snapshotPath = await persistSnapshot(runtime.profile.name, hash, snapshot);
+    const syncPayload = {
+        workspace: workspaceSlug,
+        command: "sync",
+        snapshot,
+        hash,
+        sent_at: timestamp,
+    };
+    const flushResult = await flushQueue({
+        profile: runtime.profile.name,
+        accessToken: freshSession.accessToken,
+        apiClient,
+        logger: runtime.logger,
+        queueMaxRetries: runtime.config.queueMaxRetries,
+    });
+    if (flushResult.delivered > 0 || flushResult.kept > 0) {
+        runtime.logger.info(`fila local processada: ${flushResult.delivered} entregues, ${flushResult.kept} mantidos.`);
+    }
+    try {
+        await apiClient.sync(freshSession.accessToken, syncPayload);
+        await updateProfileState(runtime.profile.name, {
+            lastCommand: "sync",
+            lastSyncAt: timestamp,
+            lastWorkspace: workspaceSlug,
+            lastSyncHash: hash,
+            lastSyncStatus: "success",
+            lastError: null,
+            lastSnapshotPath: snapshotPath,
+        });
+        runtime.logger.success("sincronização concluída.");
+        return 0;
+    }
+    catch (error) {
+        await queueSync(runtime.profile.name, syncPayload, error);
+        await updateProfileState(runtime.profile.name, {
+            lastCommand: "sync",
+            lastWorkspace: workspaceSlug,
+            lastSyncHash: hash,
+            lastSyncStatus: "queued",
+            lastError: error instanceof Error ? error.message : String(error),
+            lastSnapshotPath: snapshotPath,
+        });
+        runtime.logger.warn("API indisponível no momento. O sync foi enfileirado localmente.");
+        return 0;
+    }
+}
+//# sourceMappingURL=sync.js.map

package/dist/commands/whoami.d.ts

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

package/dist/commands/whoami.js

@@ -0,0 +1,32 @@
+import { ensureSessionAvailable } from "../core/config.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";
+export async function runWhoAmICommand(cliVersion) {
+    const runtime = await loadRuntimeStatus();
+    const session = await ensureSessionAvailable(runtime.profile.name);
+    const machine = await collectMachineContext(runtime.device, runtime.config);
+    const runtimeContext = await collectRuntimeContext(cliVersion, "whoami", 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 me = await apiClient.getCurrentUser(freshSession.accessToken);
+    process.stdout.write(`Perfil: ${runtime.profile.name}\n`);
+    process.stdout.write(`ID: ${me.id}\n`);
+    process.stdout.write(`Tipo: ${me.type}\n`);
+    process.stdout.write(`Nome: ${me.name ?? "n/a"}\n`);
+    process.stdout.write(`Email: ${me.email ?? "n/a"}\n`);
+    process.stdout.write(`Workspace: ${freshSession.workspace}\n`);
+    process.stdout.write(`Orgs: ${me.orgIds.join(", ") || "nenhuma"}\n`);
+    process.stdout.write(`Capabilities: ${me.capabilities.join(", ") || "nenhuma"}\n`);
+    return 0;
+}
+//# sourceMappingURL=whoami.js.map

package/dist/commands/workspace.d.ts

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

package/dist/commands/workspace.js

@@ -0,0 +1,66 @@
+import { getStringOption, parseArgs, requirePositional } from "../core/cli.js";
+import { ensureSessionAvailable, upsertProfile } from "../core/config.js";
+import { collectGitContext } from "../core/git.js";
+import { loadRuntimeStatus } from "../core/runtime.js";
+import { VectorPlaneApiClient } from "../core/api.js";
+import { bindWorkspaceToRoot, clearBoundWorkspace, getBindingStore, resolveWorkspaceRoot } from "../core/workspace-binding.js";
+import { ValidationError } from "../core/errors.js";
+export async function runWorkspaceCommand(args) {
+    const parsed = parseArgs(args);
+    const [subcommand] = parsed.positionals;
+    const runtime = await loadRuntimeStatus();
+    const git = await collectGitContext(process.cwd());
+    const rootPath = resolveWorkspaceRoot(process.cwd(), git);
+    if (!subcommand || subcommand === "current") {
+        const store = await getBindingStore();
+        const binding = store.bindings[rootPath];
+        process.stdout.write(`Root: ${rootPath}\n`);
+        process.stdout.write(`Workspace: ${binding?.workspace ?? runtime.profile.workspace ?? "nenhum"}\n`);
+        process.stdout.write(`Source: ${binding?.source ?? "perfil"}\n`);
+        return 0;
+    }
+    if (subcommand === "use") {
+        const workspace = requirePositional(parsed, 1, "Informe o workspace.");
+        await bindWorkspaceToRoot({
+            rootPath,
+            workspace,
+            repoUrl: git.remoteOrigin,
+            source: "manual",
+        });
+        await upsertProfile(runtime.profile.name, { workspace });
+        process.stdout.write(`Workspace associado a ${rootPath}: ${workspace}\n`);
+        return 0;
+    }
+    if (subcommand === "clear") {
+        await clearBoundWorkspace(rootPath);
+        process.stdout.write(`Binding removido de ${rootPath}\n`);
+        return 0;
+    }
+    if (subcommand === "resolve") {
+        const session = await ensureSessionAvailable(runtime.profile.name);
+        const repoUrl = getStringOption(parsed, "repo") ?? git.remoteOrigin;
+        if (!repoUrl) {
+            throw new ValidationError("Nenhum remote git disponível para resolver o workspace.");
+        }
+        const apiClient = new VectorPlaneApiClient(runtime.profile.apiBaseUrl, runtime.config.requestTimeoutMs, runtime.logger);
+        const response = await apiClient.resolveWorkspaceByRepo(session.accessToken, {
+            repoUrl,
+            orgId: runtime.profile.orgId ?? undefined,
+        });
+        const workspace = String(response.workspaceId ?? response.id ?? response.slug ?? "");
+        if (!workspace) {
+            throw new ValidationError("A resolução de workspace não retornou um identificador utilizável.");
+        }
+        await bindWorkspaceToRoot({
+            rootPath,
+            workspace,
+            repoUrl,
+            source: "api-resolve",
+        });
+        await upsertProfile(runtime.profile.name, { workspace });
+        process.stdout.write(`Workspace resolvido: ${workspace}\n`);
+        return 0;
+    }
+    throw new ValidationError("Subcomando de workspace não suportado.");
+}
+//# sourceMappingURL=workspace.js.map

package/dist/core/api.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from "./logger.js";
+import type { CurrentUserResponse, AuthCodeExchangeRequest, AuthTokenExchangeResponse, RefreshTokenRequest } from "../types/auth.js";
+import type { AgentCheckoutRequest, AgentHeartbeatRequest, AgentSessionRequest, AgentSessionResponse, EventRequest, ResolveWorkspaceRequest, ResolveWorkspaceResponse, SyncRequest, SyncResponse } from "../types/api.js";
+export declare class VectorPlaneApiClient {
+    private readonly apiBaseUrl;
+    private readonly timeoutMs;
+    private readonly logger;
+    constructor(apiBaseUrl: string, timeoutMs: number, logger: Logger);
+    exchangeToken(payload: AuthCodeExchangeRequest): Promise<AuthTokenExchangeResponse>;
+    refreshToken(payload: RefreshTokenRequest): Promise<AuthTokenExchangeResponse>;
+    getCurrentUser(accessToken: string): Promise<CurrentUserResponse>;
+    sync(accessToken: string, payload: SyncRequest): Promise<SyncResponse>;
+    sendEvent(accessToken: string, payload: EventRequest): Promise<Record<string, unknown>>;
+    resolveWorkspaceByRepo(accessToken: string, payload: ResolveWorkspaceRequest): Promise<ResolveWorkspaceResponse>;
+    getWorkspaceContext(accessToken: string, workspaceId: string): Promise<Record<string, unknown>>;
+    getWorkspaceSnapshot(accessToken: string, workspaceId: string): Promise<Record<string, unknown>>;
+    getWorkspaceDeliveryContext(accessToken: string, workspaceId: string): Promise<Record<string, unknown>>;
+    getAgentSetup(accessToken: string, workspaceId: string): Promise<Record<string, unknown>>;
+    checkInAgent(accessToken: string, payload: AgentSessionRequest): Promise<AgentSessionResponse>;
+    heartbeatAgent(accessToken: string, payload: AgentHeartbeatRequest): Promise<AgentSessionResponse>;
+    checkOutAgent(accessToken: string, payload: AgentCheckoutRequest): Promise<AgentSessionResponse>;
+    getHealth(): Promise<Record<string, unknown>>;
+    getReady(): Promise<Record<string, unknown>>;
+}

package/dist/core/api.js

@@ -0,0 +1,190 @@
+import { ApiError } from "./errors.js";
+async function parseBody(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+        return response.json();
+    }
+    return response.text();
+}
+function unwrapEnvelope(body) {
+    if (body && typeof body === "object" && "success" in body) {
+        const envelope = body;
+        if (envelope.success) {
+            return envelope.data;
+        }
+        const message = typeof envelope.error?.message === "string" ? envelope.error.message : "Falha na API do VectorPlane.";
+        throw new ApiError(message, undefined, body);
+    }
+    return body;
+}
+async function requestJson(url, init, timeoutMs, logger) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        logger.debug("http_request", { method: init.method ?? "GET", url });
+        const response = await fetch(url, { ...init, signal: controller.signal });
+        const body = await parseBody(response);
+        if (!response.ok) {
+            const message = typeof body === "string"
+                ? body
+                : typeof body === "object" && body && "error" in body
+                    ? String((body.error?.message) ?? `HTTP ${response.status}`)
+                    : typeof body === "object" && body && "message" in body
+                        ? String(body.message)
+                        : `HTTP ${response.status}`;
+            throw new ApiError(message, response.status, body);
+        }
+        return unwrapEnvelope(body);
+    }
+    catch (error) {
+        if (error instanceof ApiError) {
+            throw error;
+        }
+        if (error.name === "AbortError") {
+            throw new ApiError("A requisição para a API expirou.");
+        }
+        throw new ApiError("Falha na comunicação com a API do VectorPlane.", undefined, error);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function authHeaders(accessToken) {
+    return {
+        "Authorization": `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+    };
+}
+export class VectorPlaneApiClient {
+    apiBaseUrl;
+    timeoutMs;
+    logger;
+    constructor(apiBaseUrl, timeoutMs, logger) {
+        this.apiBaseUrl = apiBaseUrl;
+        this.timeoutMs = timeoutMs;
+        this.logger = logger;
+    }
+    async exchangeToken(payload) {
+        return requestJson(`${this.apiBaseUrl}/cli/token/exchange`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async refreshToken(payload) {
+        return requestJson(`${this.apiBaseUrl}/cli/token/refresh`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async getCurrentUser(accessToken) {
+        return requestJson(`${this.apiBaseUrl}/auth/me`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async sync(accessToken, payload) {
+        return requestJson(`${this.apiBaseUrl}/sync`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async sendEvent(accessToken, payload) {
+        return requestJson(`${this.apiBaseUrl}/events`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async resolveWorkspaceByRepo(accessToken, payload) {
+        return requestJson(`${this.apiBaseUrl}/cli/workspace/resolve`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async getWorkspaceContext(accessToken, workspaceId) {
+        return requestJson(`${this.apiBaseUrl}/cli/workspace/${workspaceId}/context`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async getWorkspaceSnapshot(accessToken, workspaceId) {
+        return requestJson(`${this.apiBaseUrl}/cli/workspace/${workspaceId}/snapshot`, {
+            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",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async getAgentSetup(accessToken, workspaceId) {
+        return requestJson(`${this.apiBaseUrl}/cli/workspace/${workspaceId}/agent-setup`, {
+            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",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify({
+                agentName: payload.agentName,
+                agentType: payload.agentType,
+                clientName: payload.clientName,
+                clientInstanceId: payload.clientInstanceId,
+                repoUrl: payload.repoUrl,
+                branch: payload.branch,
+                commitSha: payload.commitSha,
+                metadata: payload.metadata,
+            }),
+        }, this.timeoutMs, this.logger);
+    }
+    async heartbeatAgent(accessToken, payload) {
+        return requestJson(`${this.apiBaseUrl}/agent-sessions/${payload.sessionId}/heartbeat`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify({
+                clientInstanceId: payload.clientInstanceId,
+                branch: payload.branch,
+                commitSha: payload.commitSha,
+                metadata: payload.metadata,
+            }),
+        }, this.timeoutMs, this.logger);
+    }
+    async checkOutAgent(accessToken, payload) {
+        return requestJson(`${this.apiBaseUrl}/agent-sessions/${payload.sessionId}/check-out`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify({
+                metadata: payload.metadata,
+            }),
+        }, this.timeoutMs, this.logger);
+    }
+    async getHealth() {
+        return requestJson(`${this.apiBaseUrl}/health`, {
+            method: "GET",
+        }, this.timeoutMs, this.logger);
+    }
+    async getReady() {
+        return requestJson(`${this.apiBaseUrl}/ready`, {
+            method: "GET",
+        }, this.timeoutMs, this.logger);
+    }
+}
+//# sourceMappingURL=api.js.map

package/dist/core/auth.d.ts

@@ -0,0 +1,16 @@
+import type { CliConfig, CliProfileConfig } from "../types/config.js";
+import type { AuthSession } from "../types/auth.js";
+import type { DeviceIdentity, MachineContext, RuntimeContext } from "../types/machine.js";
+import { VectorPlaneApiClient } from "./api.js";
+import type { Logger } from "./logger.js";
+export declare function generateLoginState(): string;
+export declare function openBrowser(url: string): Promise<boolean>;
+export declare function runLoginFlow(params: {
+    config: CliConfig;
+    profile: CliProfileConfig;
+    machine: MachineContext;
+    runtime: RuntimeContext;
+    device: DeviceIdentity;
+    apiClient: VectorPlaneApiClient;
+    logger: Logger;
+}): Promise<AuthSession>;