@vectorplane/ctrl-cli 0.1.0

package/dist/core/git.js

@@ -0,0 +1,66 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import path from "node:path";
+const execFileAsync = promisify(execFile);
+function sanitizeRemoteUrl(remote) {
+    if (!remote) {
+        return null;
+    }
+    if (remote.startsWith("git@")) {
+        const [left, right] = remote.split(":", 2);
+        const host = left.split("@")[1];
+        return `ssh://${host}/${right.replace(/\.git$/i, "")}`;
+    }
+    try {
+        const url = new URL(remote);
+        url.username = "";
+        url.password = "";
+        url.pathname = url.pathname.replace(/\.git$/i, "");
+        return url.toString();
+    }
+    catch {
+        return remote.replace(/:\/\/[^@]+@/, "://");
+    }
+}
+async function runGit(args, cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", args, { cwd });
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+export async function collectGitContext(cwd) {
+    const root = await runGit(["rev-parse", "--show-toplevel"], cwd);
+    if (!root) {
+        return {
+            isRepository: false,
+            rootPath: null,
+            branch: null,
+            commitHash: null,
+            remoteOrigin: null,
+            repositoryName: null,
+            hasLocalChanges: false,
+            statusSummary: [],
+        };
+    }
+    const [branch, commitHash, remoteOriginRaw, statusRaw] = await Promise.all([
+        runGit(["rev-parse", "--abbrev-ref", "HEAD"], cwd),
+        runGit(["rev-parse", "HEAD"], cwd),
+        runGit(["remote", "get-url", "origin"], cwd),
+        runGit(["status", "--short"], cwd),
+    ]);
+    const statusSummary = statusRaw ? statusRaw.split("\n").filter(Boolean).slice(0, 20) : [];
+    return {
+        isRepository: true,
+        rootPath: root,
+        branch,
+        commitHash,
+        remoteOrigin: sanitizeRemoteUrl(remoteOriginRaw),
+        repositoryName: path.basename(root),
+        hasLocalChanges: statusSummary.length > 0,
+        statusSummary,
+    };
+}
+//# sourceMappingURL=git.js.map

package/dist/core/logger.d.ts

@@ -0,0 +1,8 @@
+export interface Logger {
+    info(message: string, meta?: unknown): void;
+    success(message: string, meta?: unknown): void;
+    warn(message: string, meta?: unknown): void;
+    error(message: string, meta?: unknown): void;
+    debug(message: string, meta?: unknown): void;
+}
+export declare function createLogger(debugEnabled: boolean): Logger;

package/dist/core/logger.js

@@ -0,0 +1,52 @@
+import { PRODUCT_NAME, SENSITIVE_KEYS } from "./constants.js";
+function maskValue(value) {
+    if (value.length <= 8) {
+        return "********";
+    }
+    return `${value.slice(0, 4)}...${value.slice(-2)}`;
+}
+function sanitizeUnknown(input) {
+    if (Array.isArray(input)) {
+        return input.map((item) => sanitizeUnknown(item));
+    }
+    if (!input || typeof input !== "object") {
+        return typeof input === "string" && input.length > 64 ? maskValue(input) : input;
+    }
+    const record = input;
+    const sanitized = {};
+    for (const [key, value] of Object.entries(record)) {
+        const sensitive = SENSITIVE_KEYS.some((item) => key.toLowerCase().includes(item));
+        sanitized[key] = sensitive && typeof value === "string" ? maskValue(value) : sanitizeUnknown(value);
+    }
+    return sanitized;
+}
+function writeLine(kind, message, meta) {
+    const stream = kind === "error" ? process.stderr : process.stdout;
+    stream.write(`${PRODUCT_NAME}: ${message}\n`);
+    if (meta && kind === "debug") {
+        stream.write(`${JSON.stringify(sanitizeUnknown(meta), null, 2)}\n`);
+    }
+}
+export function createLogger(debugEnabled) {
+    return {
+        info(message, meta) {
+            writeLine("info", message, meta);
+        },
+        success(message, meta) {
+            writeLine("success", message, meta);
+        },
+        warn(message, meta) {
+            writeLine("warn", message, meta);
+        },
+        error(message, meta) {
+            writeLine("error", message, meta);
+        },
+        debug(message, meta) {
+            if (!debugEnabled) {
+                return;
+            }
+            writeLine("debug", message, meta);
+        },
+    };
+}
+//# sourceMappingURL=logger.js.map

package/dist/core/machine.d.ts

@@ -0,0 +1,4 @@
+import type { CliConfig } from "../types/config.js";
+import type { DeviceIdentity, MachineContext, RuntimeContext } from "../types/machine.js";
+export declare function collectRuntimeContext(cliVersion: string, command: string, args: string[]): Promise<RuntimeContext>;
+export declare function collectMachineContext(identity: DeviceIdentity, config: CliConfig): Promise<MachineContext>;

package/dist/core/machine.js

@@ -0,0 +1,87 @@
+import os from "node:os";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { collectSafeEnvironmentVariables } from "./env.js";
+const execFileAsync = promisify(execFile);
+async function detectNpmVersion() {
+    try {
+        const { stdout } = await execFileAsync("npm", ["--version"]);
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+async function detectPublicIp(timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch("https://api.ipify.org?format=json", { signal: controller.signal });
+        if (!response.ok) {
+            return null;
+        }
+        const body = await response.json();
+        return typeof body.ip === "string" ? body.ip : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function collectNetworkInterfaces() {
+    const interfaces = os.networkInterfaces();
+    const results = [];
+    for (const [name, entries] of Object.entries(interfaces)) {
+        for (const entry of entries ?? []) {
+            results.push({
+                name,
+                family: entry.family,
+                mac: entry.mac,
+                address: entry.address,
+                internal: entry.internal,
+                cidr: entry.cidr ?? null,
+            });
+        }
+    }
+    return results.sort((left, right) => left.name.localeCompare(right.name) || left.address.localeCompare(right.address));
+}
+export async function collectRuntimeContext(cliVersion, command, args) {
+    return {
+        nodeVersion: process.version,
+        npmVersion: await detectNpmVersion(),
+        cliVersion,
+        pid: process.pid,
+        command,
+        args,
+        shell: process.env.SHELL ?? null,
+        safeEnv: collectSafeEnvironmentVariables(),
+    };
+}
+export async function collectMachineContext(identity, config) {
+    const cpus = os.cpus();
+    return {
+        machineId: identity.machineId,
+        hostname: os.hostname(),
+        platform: process.platform,
+        osRelease: os.release(),
+        architecture: os.arch(),
+        kernelVersion: os.version(),
+        username: os.userInfo().username,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        locale: Intl.DateTimeFormat().resolvedOptions().locale,
+        shell: process.env.SHELL ?? null,
+        currentDirectory: process.cwd(),
+        homeDirectory: os.homedir(),
+        cpuModel: cpus[0]?.model ?? null,
+        cpuCount: cpus.length,
+        loadAverage: os.loadavg(),
+        memoryTotal: os.totalmem(),
+        memoryFree: os.freemem(),
+        uptimeSeconds: os.uptime(),
+        networkInterfaces: collectNetworkInterfaces(),
+        publicIp: await detectPublicIp(config.publicIpLookupTimeoutMs),
+    };
+}
+//# sourceMappingURL=machine.js.map

package/dist/core/queue.d.ts

@@ -0,0 +1,14 @@
+import type { Logger } from "./logger.js";
+import { VectorPlaneApiClient } from "./api.js";
+export declare function queueSync(profile: string, payload: Record<string, unknown>, error: unknown): Promise<void>;
+export declare function queueEvent(profile: string, payload: Record<string, unknown>, error: unknown): Promise<void>;
+export declare function flushQueue(params: {
+    profile: string;
+    accessToken: string;
+    apiClient: VectorPlaneApiClient;
+    logger: Logger;
+    queueMaxRetries: number;
+}): Promise<{
+    delivered: number;
+    kept: number;
+}>;

package/dist/core/queue.js

@@ -0,0 +1,62 @@
+import { randomUUID } from "node:crypto";
+import { enqueueItem, loadQueue, removeQueueItem, replaceQueueItem } from "./config.js";
+import { ApiError } from "./errors.js";
+export async function queueSync(profile, payload, error) {
+    await enqueueItem({
+        id: randomUUID(),
+        profile,
+        kind: "sync",
+        createdAt: new Date().toISOString(),
+        attempts: 0,
+        lastError: error instanceof Error ? error.message : String(error),
+        payload,
+    });
+}
+export async function queueEvent(profile, payload, error) {
+    await enqueueItem({
+        id: randomUUID(),
+        profile,
+        kind: "event",
+        createdAt: new Date().toISOString(),
+        attempts: 0,
+        lastError: error instanceof Error ? error.message : String(error),
+        payload,
+    });
+}
+export async function flushQueue(params) {
+    const queue = await loadQueue();
+    let delivered = 0;
+    let kept = 0;
+    for (const item of queue.items.filter((entry) => entry.profile === params.profile)) {
+        try {
+            if (item.kind === "sync") {
+                await params.apiClient.sync(params.accessToken, item.payload);
+            }
+            else {
+                await params.apiClient.sendEvent(params.accessToken, item.payload);
+            }
+            await removeQueueItem(item.id);
+            delivered += 1;
+        }
+        catch (error) {
+            const nextItem = {
+                ...item,
+                attempts: item.attempts + 1,
+                lastError: error instanceof Error ? error.message : String(error),
+            };
+            if (nextItem.attempts >= params.queueMaxRetries) {
+                await removeQueueItem(item.id);
+                params.logger.warn(`item da fila descartado após ${params.queueMaxRetries} tentativas.`);
+            }
+            else {
+                await replaceQueueItem(nextItem);
+                kept += 1;
+            }
+            if (!(error instanceof ApiError)) {
+                params.logger.debug("queue_flush_error", { error: nextItem.lastError, kind: item.kind });
+            }
+        }
+    }
+    return { delivered, kept };
+}
+//# sourceMappingURL=queue.js.map

package/dist/core/runtime.d.ts

@@ -0,0 +1,13 @@
+import type { CliConfig, CliProfileConfig } from "../types/config.js";
+import type { Logger } from "./logger.js";
+import { loadOrCreateDeviceIdentity, loadState } from "./config.js";
+export interface RuntimeServices {
+    config: CliConfig;
+    profile: CliProfileConfig;
+    logger: Logger;
+}
+export declare function loadRuntimeServices(): Promise<RuntimeServices>;
+export declare function loadRuntimeStatus(): Promise<RuntimeServices & {
+    state: Awaited<ReturnType<typeof loadState>>;
+    device: Awaited<ReturnType<typeof loadOrCreateDeviceIdentity>>;
+}>;

package/dist/core/runtime.js

@@ -0,0 +1,16 @@
+import { createLogger } from "./logger.js";
+import { getActiveProfile, loadConfig, loadOrCreateDeviceIdentity, loadState } from "./config.js";
+export async function loadRuntimeServices() {
+    const config = await loadConfig();
+    return {
+        config,
+        profile: getActiveProfile(config),
+        logger: createLogger(config.debug),
+    };
+}
+export async function loadRuntimeStatus() {
+    const runtime = await loadRuntimeServices();
+    const [state, device] = await Promise.all([loadState(), loadOrCreateDeviceIdentity()]);
+    return { ...runtime, state, device };
+}
+//# sourceMappingURL=runtime.js.map

package/dist/core/serializer.d.ts

@@ -0,0 +1,7 @@
+import type { SnapshotPayload } from "../types/snapshot.js";
+export declare function serializeJson(value: unknown): string;
+export declare function createStableHash(value: unknown): string;
+export declare function buildSnapshotEnvelope(snapshot: SnapshotPayload): {
+    snapshot: SnapshotPayload;
+    hash: string;
+};

package/dist/core/serializer.js

@@ -0,0 +1,31 @@
+import { createHash } from "node:crypto";
+function normalize(value) {
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => normalize(item));
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (!value || typeof value !== "object") {
+        return String(value);
+    }
+    const sortedEntries = Object.entries(value)
+        .filter(([, item]) => item !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => [key, normalize(item)]);
+    return Object.fromEntries(sortedEntries);
+}
+export function serializeJson(value) {
+    return JSON.stringify(normalize(value));
+}
+export function createStableHash(value) {
+    return createHash("sha256").update(serializeJson(value)).digest("hex");
+}
+export function buildSnapshotEnvelope(snapshot) {
+    const hash = createStableHash(snapshot);
+    return { snapshot, hash };
+}
+//# sourceMappingURL=serializer.js.map

package/dist/core/server.d.ts

@@ -0,0 +1,10 @@
+export interface CallbackResult {
+    code: string;
+    state: string;
+}
+export interface CallbackServerHandle {
+    waitForCallback(timeoutMs: number): Promise<CallbackResult>;
+    close(): Promise<void>;
+    callbackUrl: string;
+}
+export declare function createCallbackServer(host: string, port: number, callbackPath: string, expectedState: string): Promise<CallbackServerHandle>;

package/dist/core/server.js

@@ -0,0 +1,84 @@
+import http from "node:http";
+import { AuthError } from "./errors.js";
+export async function createCallbackServer(host, port, callbackPath, expectedState) {
+    let resolveCallback = null;
+    let rejectCallback = null;
+    let settled = false;
+    const server = http.createServer((request, response) => {
+        try {
+            const url = new URL(request.url ?? "/", `http://${host}:${port}`);
+            if (url.pathname !== callbackPath) {
+                response.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+                response.end("VectorPlane callback not found.");
+                return;
+            }
+            const code = url.searchParams.get("code");
+            const state = url.searchParams.get("state");
+            if (!code || !state) {
+                response.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+                response.end("Missing code or state.");
+                if (!settled) {
+                    settled = true;
+                    rejectCallback?.(new AuthError("Callback inválido: parâmetros obrigatórios ausentes."));
+                }
+                return;
+            }
+            if (state !== expectedState) {
+                response.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+                response.end("State mismatch.");
+                if (!settled) {
+                    settled = true;
+                    rejectCallback?.(new AuthError("Falha de validação de segurança no login. O parâmetro state não confere."));
+                }
+                return;
+            }
+            response.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+            response.end("<html><body><p>VectorPlane: autenticação recebida. Você já pode voltar ao terminal.</p></body></html>");
+            if (!settled) {
+                settled = true;
+                resolveCallback?.({ code, state });
+            }
+        }
+        catch (error) {
+            response.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+            response.end("VectorPlane callback error.");
+            if (!settled) {
+                settled = true;
+                rejectCallback?.(error);
+            }
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", (error) => reject(error));
+        server.listen(port, host, () => resolve());
+    }).catch((error) => {
+        const code = error.code;
+        if (code === "EADDRINUSE") {
+            throw new AuthError(`A porta ${port} já está em uso. Libere a porta e tente novamente.`);
+        }
+        throw new AuthError("Não foi possível iniciar o callback local de autenticação.", error);
+    });
+    const callbackUrl = `http://${host}:${server.address().port}${callbackPath}`;
+    return {
+        callbackUrl,
+        async waitForCallback(timeoutMs) {
+            return new Promise((resolve, reject) => {
+                resolveCallback = resolve;
+                rejectCallback = reject;
+                const timer = setTimeout(() => {
+                    if (!settled) {
+                        settled = true;
+                        reject(new AuthError("Tempo esgotado aguardando a autenticação no navegador."));
+                    }
+                }, timeoutMs);
+                server.once("close", () => clearTimeout(timer));
+            });
+        },
+        async close() {
+            await new Promise((resolve, reject) => {
+                server.close((error) => error ? reject(error) : resolve());
+            }).catch(() => undefined);
+        },
+    };
+}
+//# sourceMappingURL=server.js.map

package/dist/core/session.d.ts

@@ -0,0 +1,16 @@
+import type { AuthSession } from "../types/auth.js";
+import type { DeviceIdentity, MachineContext, RuntimeContext } from "../types/machine.js";
+import type { CliProfileConfig } from "../types/config.js";
+import type { Logger } from "./logger.js";
+import { VectorPlaneApiClient } from "./api.js";
+export declare function isSessionExpired(session: AuthSession, offsetMs?: number): boolean;
+export declare function ensureFreshSession(params: {
+    profileName: string;
+    session: AuthSession;
+    machine: MachineContext;
+    runtime: RuntimeContext;
+    device: DeviceIdentity;
+    apiClient: VectorPlaneApiClient;
+    logger: Logger;
+}): Promise<AuthSession>;
+export declare function resolveWorkspaceSlug(profile: CliProfileConfig, session: AuthSession | null, explicit: string | undefined, bound: string | null, stateWorkspace: string | null): string | null;

package/dist/core/session.js

@@ -0,0 +1,35 @@
+import { AuthError } from "./errors.js";
+import { CLI_CLIENT_ID } from "./constants.js";
+import { saveSession } from "./config.js";
+export function isSessionExpired(session, offsetMs = 60_000) {
+    return new Date(session.expiresAt).getTime() <= Date.now() + offsetMs;
+}
+export async function ensureFreshSession(params) {
+    if (!isSessionExpired(params.session)) {
+        return params.session;
+    }
+    params.logger.info("renovando sessão local...");
+    const refreshPayload = {
+        refresh_token: params.session.refreshToken,
+        client: CLI_CLIENT_ID,
+    };
+    const refreshed = await params.apiClient.refreshToken(refreshPayload);
+    if (!refreshed.access_token || !refreshed.refresh_token) {
+        throw new AuthError("A renovação de sessão retornou credenciais inválidas.");
+    }
+    const nextSession = {
+        accessToken: refreshed.access_token,
+        refreshToken: refreshed.refresh_token,
+        workspace: refreshed.workspace || params.session.workspace,
+        tokenType: refreshed.token_type,
+        expiresIn: refreshed.expires_in,
+        obtainedAt: new Date().toISOString(),
+        expiresAt: new Date(Date.now() + refreshed.expires_in * 1000).toISOString(),
+    };
+    await saveSession(nextSession, params.profileName);
+    return nextSession;
+}
+export function resolveWorkspaceSlug(profile, session, explicit, bound, stateWorkspace) {
+    return explicit ?? bound ?? profile.workspace ?? session?.workspace ?? stateWorkspace ?? null;
+}
+//# sourceMappingURL=session.js.map

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

@@ -0,0 +1,15 @@
+import type { CliProfileConfig, WorkspaceBindingStore } from "../types/config.js";
+import type { GitContext } from "../types/workspace.js";
+export declare function resolveWorkspaceRoot(cwd: string, git: GitContext): string;
+export declare function deriveClientInstanceId(machineId: string, workspaceRoot: string, git: GitContext): string;
+export declare function getBoundWorkspace(rootPath: string): Promise<string | null>;
+export declare function getBindingStore(): Promise<WorkspaceBindingStore>;
+export declare function bindWorkspaceToRoot(params: {
+    rootPath: string;
+    workspace: string;
+    repoUrl: string | null;
+    source: "manual" | "api-resolve" | "session";
+}): Promise<void>;
+export declare function clearBoundWorkspace(rootPath: string): Promise<void>;
+export declare function resolveWorkspacePreference(profile: CliProfileConfig, boundWorkspace: string | null): string | null;
+export declare function relativeRoot(rootPath: string): string;

package/dist/core/workspace-binding.js

@@ -0,0 +1,41 @@
+import path from "node:path";
+import { bindWorkspace, loadWorkspaceBindings, unbindWorkspace } from "./config.js";
+import { createStableHash } from "./serializer.js";
+export function resolveWorkspaceRoot(cwd, git) {
+    return git.rootPath ?? cwd;
+}
+export function deriveClientInstanceId(machineId, workspaceRoot, git) {
+    const hash = createStableHash({
+        machineId,
+        workspaceRoot,
+        branch: git.branch,
+        repositoryName: git.repositoryName,
+    });
+    return `vpci-${hash.slice(0, 24)}`;
+}
+export async function getBoundWorkspace(rootPath) {
+    const store = await loadWorkspaceBindings();
+    return store.bindings[rootPath]?.workspace ?? null;
+}
+export async function getBindingStore() {
+    return loadWorkspaceBindings();
+}
+export async function bindWorkspaceToRoot(params) {
+    await bindWorkspace({
+        rootPath: params.rootPath,
+        workspace: params.workspace,
+        repoUrl: params.repoUrl,
+        resolvedAt: new Date().toISOString(),
+        source: params.source,
+    });
+}
+export async function clearBoundWorkspace(rootPath) {
+    await unbindWorkspace(rootPath);
+}
+export function resolveWorkspacePreference(profile, boundWorkspace) {
+    return boundWorkspace ?? profile.workspace ?? null;
+}
+export function relativeRoot(rootPath) {
+    return path.basename(rootPath);
+}
+//# sourceMappingURL=workspace-binding.js.map

package/dist/core/workspace.d.ts

@@ -0,0 +1,2 @@
+import type { GitContext, WorkspaceContext } from "../types/workspace.js";
+export declare function collectWorkspaceContext(cwd: string, git: GitContext): Promise<WorkspaceContext>;