@vectorplane/ctrl-cli 0.1.0

package/dist/core/auth.js

@@ -0,0 +1,71 @@
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { CALLBACK_TIMEOUT_MS, CLI_CLIENT_ID } from "./constants.js";
+import { AuthError } from "./errors.js";
+import { createCallbackServer } from "./server.js";
+function buildLoginUrl(profile, callbackUrl, state) {
+    const url = new URL("/cli/login", profile.appBaseUrl);
+    url.searchParams.set("redirect_uri", callbackUrl);
+    url.searchParams.set("state", state);
+    return url.toString();
+}
+export function generateLoginState() {
+    return randomBytes(24).toString("hex");
+}
+export async function openBrowser(url) {
+    const platform = process.platform;
+    const command = platform === "darwin"
+        ? ["open", url]
+        : platform === "win32"
+            ? ["cmd", "/c", "start", "", url]
+            : ["xdg-open", url];
+    return new Promise((resolve) => {
+        const child = spawn(command[0], command.slice(1), {
+            detached: platform !== "win32",
+            stdio: "ignore",
+        });
+        child.once("error", () => resolve(false));
+        child.once("spawn", () => {
+            child.unref();
+            resolve(true);
+        });
+    });
+}
+export async function runLoginFlow(params) {
+    const state = generateLoginState();
+    const callbackServer = await createCallbackServer(params.config.callbackHost, params.config.callbackPort, params.config.callbackPath, state);
+    try {
+        const loginUrl = buildLoginUrl(params.profile, callbackServer.callbackUrl, state);
+        params.logger.info("abrindo navegador para autenticação...");
+        const opened = await openBrowser(loginUrl);
+        if (!opened) {
+            params.logger.warn("não foi possível abrir o navegador automaticamente.");
+            process.stdout.write(`${loginUrl}\n`);
+        }
+        params.logger.info("aguardando confirmação...");
+        const callback = await callbackServer.waitForCallback(CALLBACK_TIMEOUT_MS);
+        const payload = {
+            code: callback.code,
+            client: CLI_CLIENT_ID,
+            device: params.machine,
+            runtime: params.runtime,
+        };
+        const tokenResponse = await params.apiClient.exchangeToken(payload);
+        if (!tokenResponse.access_token || !tokenResponse.refresh_token) {
+            throw new AuthError("A API retornou uma sessão inválida.");
+        }
+        return {
+            accessToken: tokenResponse.access_token,
+            refreshToken: tokenResponse.refresh_token,
+            workspace: tokenResponse.workspace,
+            tokenType: tokenResponse.token_type,
+            expiresIn: tokenResponse.expires_in,
+            obtainedAt: new Date().toISOString(),
+            expiresAt: new Date(Date.now() + tokenResponse.expires_in * 1000).toISOString(),
+        };
+    }
+    finally {
+        await callbackServer.close();
+    }
+}
+//# sourceMappingURL=auth.js.map

package/dist/core/cli.d.ts

@@ -0,0 +1,9 @@
+export interface ParsedArgs {
+    positionals: string[];
+    options: Record<string, string | boolean>;
+}
+export declare function parseArgs(args: string[]): ParsedArgs;
+export declare function getStringOption(parsed: ParsedArgs, key: string): string | undefined;
+export declare function getBooleanOption(parsed: ParsedArgs, key: string): boolean;
+export declare function requirePositional(parsed: ParsedArgs, index: number, message: string): string;
+export declare function parseJsonOption(value: string | undefined, fallback?: Record<string, unknown>): Record<string, unknown>;

package/dist/core/cli.js

@@ -0,0 +1,66 @@
+import { ValidationError } from "./errors.js";
+export function parseArgs(args) {
+    const positionals = [];
+    const options = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index];
+        if (!current.startsWith("--")) {
+            positionals.push(current);
+            continue;
+        }
+        const option = current.slice(2);
+        const [key, inlineValue] = option.split("=", 2);
+        if (inlineValue !== undefined) {
+            options[key] = inlineValue;
+            continue;
+        }
+        const next = args[index + 1];
+        if (!next || next.startsWith("--")) {
+            options[key] = true;
+            continue;
+        }
+        options[key] = next;
+        index += 1;
+    }
+    return { positionals, options };
+}
+export function getStringOption(parsed, key) {
+    const value = parsed.options[key];
+    return typeof value === "string" ? value : undefined;
+}
+export function getBooleanOption(parsed, key) {
+    const value = parsed.options[key];
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+    }
+    return false;
+}
+export function requirePositional(parsed, index, message) {
+    const value = parsed.positionals[index];
+    if (!value) {
+        throw new ValidationError(message);
+    }
+    return value;
+}
+export function parseJsonOption(value, fallback = {}) {
+    if (!value) {
+        return fallback;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        throw new ValidationError("O payload JSON deve ser um objeto.");
+    }
+    catch (error) {
+        if (error instanceof ValidationError) {
+            throw error;
+        }
+        throw new ValidationError("Falha ao interpretar o payload JSON.", error);
+    }
+}
+//# sourceMappingURL=cli.js.map

package/dist/core/config.d.ts

@@ -0,0 +1,31 @@
+import type { AuthSession } from "../types/auth.js";
+import type { CliConfig, CliProfileConfig, CliProfileState, CliState, PendingQueueItem, QueueStore, WorkspaceBinding, WorkspaceBindingStore } from "../types/config.js";
+import type { DeviceIdentity } from "../types/machine.js";
+export declare function getActiveProfileName(config: CliConfig): string;
+export declare function getActiveProfile(config: CliConfig): CliProfileConfig;
+export declare function getProfileState(state: CliState, profile: string): CliProfileState;
+export declare function loadConfig(): Promise<CliConfig>;
+export declare function saveConfig(config: CliConfig): Promise<void>;
+export declare function upsertProfile(profileName: string, patch: Partial<CliProfileConfig>): Promise<CliConfig>;
+export declare function setActiveProfile(profileName: string): Promise<CliConfig>;
+export declare function loadSession(profileName?: string): Promise<AuthSession | null>;
+export declare function saveSession(session: AuthSession, profileName?: string): Promise<void>;
+export declare function deleteSession(profileName?: string): Promise<void>;
+export declare function loadState(): Promise<CliState>;
+export declare function saveState(state: CliState): Promise<void>;
+export declare function updateProfileState(profileName: string, patch: Partial<CliProfileState>): Promise<CliState>;
+export declare function loadQueue(): Promise<QueueStore>;
+export declare function saveQueue(queue: QueueStore): Promise<void>;
+export declare function enqueueItem(item: PendingQueueItem): Promise<void>;
+export declare function removeQueueItem(itemId: string): Promise<void>;
+export declare function replaceQueueItem(item: PendingQueueItem): Promise<void>;
+export declare function loadWorkspaceBindings(): Promise<WorkspaceBindingStore>;
+export declare function saveWorkspaceBindings(store: WorkspaceBindingStore): Promise<void>;
+export declare function bindWorkspace(binding: WorkspaceBinding): Promise<void>;
+export declare function unbindWorkspace(rootPath: string): Promise<void>;
+export declare function loadOrCreateDeviceIdentity(): Promise<DeviceIdentity>;
+export declare function ensureSessionAvailable(profileName?: string): Promise<AuthSession>;
+export declare function getConfigDirectoryPath(): Promise<string>;
+export declare function getSnapshotsDirectoryPath(): Promise<string>;
+export declare function persistSnapshot(profileName: string, hash: string, payload: unknown): Promise<string>;
+export declare function configDirectoryExists(): Promise<boolean>;

package/dist/core/config.js

@@ -0,0 +1,263 @@
+import { chmod, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { CONFIG_DIRECTORY_NAME, CONFIG_FILE_NAME, DEFAULT_CONFIG, DEFAULT_PROFILE, DEFAULT_PROFILE_NAME, DEFAULT_PROFILE_STATE, DEFAULT_QUEUE, DEFAULT_STATE, DEFAULT_WORKSPACE_BINDINGS, DEVICE_FILE_NAME, QUEUE_FILE_NAME, SESSION_FILE_NAME, SNAPSHOTS_DIRECTORY_NAME, STATE_FILE_NAME, WORKSPACE_BINDINGS_FILE_NAME, } from "./constants.js";
+import { ConfigError } from "./errors.js";
+function configDirectory() {
+    return path.join(os.homedir(), CONFIG_DIRECTORY_NAME);
+}
+function configFilePath(name) {
+    return path.join(configDirectory(), name);
+}
+function snapshotsDirectoryPath() {
+    return path.join(configDirectory(), SNAPSHOTS_DIRECTORY_NAME);
+}
+async function ensureDirectory(directoryPath) {
+    await mkdir(directoryPath, { recursive: true, mode: 0o700 });
+}
+async function ensureConfigDirectory() {
+    await ensureDirectory(configDirectory());
+}
+async function readJsonFile(filePath) {
+    try {
+        const content = await readFile(filePath, "utf8");
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw new ConfigError(`Falha ao ler ${filePath}`, error);
+    }
+}
+async function writeJsonFile(filePath, payload, mode = 0o600) {
+    await ensureConfigDirectory();
+    const tempPath = `${filePath}.${randomUUID()}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(payload, null, 2)}\n`, { mode });
+    await chmod(tempPath, mode);
+    await rename(tempPath, filePath);
+}
+function normalizeProfileConfig(name, partial) {
+    return {
+        ...DEFAULT_PROFILE,
+        ...partial,
+        name,
+    };
+}
+export function getActiveProfileName(config) {
+    return config.activeProfile in config.profiles ? config.activeProfile : DEFAULT_PROFILE_NAME;
+}
+export function getActiveProfile(config) {
+    const name = getActiveProfileName(config);
+    return normalizeProfileConfig(name, config.profiles[name]);
+}
+export function getProfileState(state, profile) {
+    return {
+        ...DEFAULT_PROFILE_STATE,
+        ...(state.profiles[profile] ?? {}),
+    };
+}
+export async function loadConfig() {
+    const filePath = configFilePath(CONFIG_FILE_NAME);
+    const stored = await readJsonFile(filePath);
+    const profiles = Object.entries(stored?.profiles ?? DEFAULT_CONFIG.profiles).reduce((accumulator, [name, value]) => {
+        accumulator[name] = normalizeProfileConfig(name, value);
+        return accumulator;
+    }, {});
+    if (!profiles[DEFAULT_PROFILE_NAME]) {
+        profiles[DEFAULT_PROFILE_NAME] = DEFAULT_PROFILE;
+    }
+    return {
+        ...DEFAULT_CONFIG,
+        ...stored,
+        profiles,
+        activeProfile: stored?.activeProfile && profiles[stored.activeProfile] ? stored.activeProfile : DEFAULT_PROFILE_NAME,
+    };
+}
+export async function saveConfig(config) {
+    await writeJsonFile(configFilePath(CONFIG_FILE_NAME), config);
+}
+export async function upsertProfile(profileName, patch) {
+    const config = await loadConfig();
+    const next = {
+        ...config,
+        profiles: {
+            ...config.profiles,
+            [profileName]: normalizeProfileConfig(profileName, {
+                ...(config.profiles[profileName] ?? DEFAULT_PROFILE),
+                ...patch,
+            }),
+        },
+    };
+    await saveConfig(next);
+    return next;
+}
+export async function setActiveProfile(profileName) {
+    const config = await loadConfig();
+    if (!config.profiles[profileName]) {
+        throw new ConfigError(`Perfil ${profileName} não existe.`);
+    }
+    const next = { ...config, activeProfile: profileName };
+    await saveConfig(next);
+    const state = await loadState();
+    await saveState({ ...state, activeProfile: profileName });
+    return next;
+}
+async function loadSessionStore() {
+    return (await readJsonFile(configFilePath(SESSION_FILE_NAME))) ?? { profiles: {} };
+}
+async function saveSessionStore(store) {
+    await writeJsonFile(configFilePath(SESSION_FILE_NAME), store);
+}
+export async function loadSession(profileName) {
+    const config = await loadConfig();
+    const store = await loadSessionStore();
+    return store.profiles[profileName ?? getActiveProfileName(config)] ?? null;
+}
+export async function saveSession(session, profileName) {
+    const config = await loadConfig();
+    const activeProfile = profileName ?? getActiveProfileName(config);
+    const store = await loadSessionStore();
+    store.profiles[activeProfile] = session;
+    await saveSessionStore(store);
+}
+export async function deleteSession(profileName) {
+    const config = await loadConfig();
+    const activeProfile = profileName ?? getActiveProfileName(config);
+    const store = await loadSessionStore();
+    delete store.profiles[activeProfile];
+    await saveSessionStore(store);
+}
+export async function loadState() {
+    const stored = await readJsonFile(configFilePath(STATE_FILE_NAME));
+    const profiles = Object.entries(stored?.profiles ?? DEFAULT_STATE.profiles).reduce((accumulator, [name, value]) => {
+        accumulator[name] = {
+            ...DEFAULT_PROFILE_STATE,
+            ...value,
+        };
+        return accumulator;
+    }, {});
+    if (!profiles[DEFAULT_PROFILE_NAME]) {
+        profiles[DEFAULT_PROFILE_NAME] = DEFAULT_PROFILE_STATE;
+    }
+    return {
+        activeProfile: stored?.activeProfile ?? DEFAULT_PROFILE_NAME,
+        profiles,
+    };
+}
+export async function saveState(state) {
+    await writeJsonFile(configFilePath(STATE_FILE_NAME), state);
+}
+export async function updateProfileState(profileName, patch) {
+    const state = await loadState();
+    const next = {
+        ...state,
+        profiles: {
+            ...state.profiles,
+            [profileName]: {
+                ...getProfileState(state, profileName),
+                ...patch,
+            },
+        },
+    };
+    await saveState(next);
+    return next;
+}
+export async function loadQueue() {
+    return (await readJsonFile(configFilePath(QUEUE_FILE_NAME))) ?? DEFAULT_QUEUE;
+}
+export async function saveQueue(queue) {
+    await writeJsonFile(configFilePath(QUEUE_FILE_NAME), queue);
+}
+export async function enqueueItem(item) {
+    const queue = await loadQueue();
+    queue.items.push(item);
+    await saveQueue(queue);
+}
+export async function removeQueueItem(itemId) {
+    const queue = await loadQueue();
+    queue.items = queue.items.filter((item) => item.id !== itemId);
+    await saveQueue(queue);
+}
+export async function replaceQueueItem(item) {
+    const queue = await loadQueue();
+    queue.items = queue.items.map((current) => current.id === item.id ? item : current);
+    await saveQueue(queue);
+}
+export async function loadWorkspaceBindings() {
+    return (await readJsonFile(configFilePath(WORKSPACE_BINDINGS_FILE_NAME))) ?? DEFAULT_WORKSPACE_BINDINGS;
+}
+export async function saveWorkspaceBindings(store) {
+    await writeJsonFile(configFilePath(WORKSPACE_BINDINGS_FILE_NAME), store);
+}
+export async function bindWorkspace(binding) {
+    const store = await loadWorkspaceBindings();
+    store.bindings[binding.rootPath] = binding;
+    await saveWorkspaceBindings(store);
+}
+export async function unbindWorkspace(rootPath) {
+    const store = await loadWorkspaceBindings();
+    delete store.bindings[rootPath];
+    await saveWorkspaceBindings(store);
+}
+export async function loadOrCreateDeviceIdentity() {
+    const filePath = configFilePath(DEVICE_FILE_NAME);
+    const now = new Date().toISOString();
+    const existing = await readJsonFile(filePath);
+    if (existing) {
+        const updated = { ...existing, lastSeenAt: now };
+        await writeJsonFile(filePath, updated);
+        return updated;
+    }
+    const created = {
+        machineId: `vp-${randomUUID().replaceAll("-", "").slice(0, 20)}`,
+        firstSeenAt: now,
+        lastSeenAt: now,
+    };
+    await writeJsonFile(filePath, created);
+    return created;
+}
+export async function ensureSessionAvailable(profileName) {
+    const session = await loadSession(profileName);
+    if (!session) {
+        throw new ConfigError("Nenhuma sessão local encontrada. Execute `vp login` primeiro.");
+    }
+    return session;
+}
+export async function getConfigDirectoryPath() {
+    await ensureConfigDirectory();
+    return configDirectory();
+}
+export async function getSnapshotsDirectoryPath() {
+    await ensureDirectory(snapshotsDirectoryPath());
+    return snapshotsDirectoryPath();
+}
+export async function persistSnapshot(profileName, hash, payload) {
+    const directory = await getSnapshotsDirectoryPath();
+    const filePath = path.join(directory, `${profileName}-${new Date().toISOString().replaceAll(":", "-")}-${hash.slice(0, 12)}.json`);
+    await writeJsonFile(filePath, payload);
+    await pruneStoredSnapshots(profileName);
+    return filePath;
+}
+async function pruneStoredSnapshots(profileName) {
+    const config = await loadConfig();
+    const directory = await getSnapshotsDirectoryPath();
+    const entries = (await readdir(directory))
+        .filter((entry) => entry.startsWith(`${profileName}-`) && entry.endsWith(".json"))
+        .sort()
+        .reverse();
+    for (const entry of entries.slice(config.snapshotStoreLimit)) {
+        await rm(path.join(directory, entry), { force: true });
+    }
+}
+export async function configDirectoryExists() {
+    try {
+        await stat(configDirectory());
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/core/constants.d.ts

@@ -0,0 +1,22 @@
+import type { CliConfig, CliProfileConfig, CliProfileState, CliState, QueueStore, WorkspaceBindingStore } from "../types/config.js";
+export declare const CLI_NAME = "vp";
+export declare const CLI_CLIENT_ID = "vp-cli";
+export declare const PRODUCT_NAME = "VectorPlane";
+export declare const CONFIG_DIRECTORY_NAME = ".vectorplane";
+export declare const SESSION_FILE_NAME = "session.json";
+export declare const CONFIG_FILE_NAME = "config.json";
+export declare const DEVICE_FILE_NAME = "device.json";
+export declare const STATE_FILE_NAME = "state.json";
+export declare const QUEUE_FILE_NAME = "queue.json";
+export declare const WORKSPACE_BINDINGS_FILE_NAME = "workspaces.json";
+export declare const SNAPSHOTS_DIRECTORY_NAME = "snapshots";
+export declare const DEFAULT_PROFILE_NAME = "default";
+export declare const DEFAULT_PROFILE: CliProfileConfig;
+export declare const DEFAULT_CONFIG: CliConfig;
+export declare const DEFAULT_PROFILE_STATE: CliProfileState;
+export declare const DEFAULT_STATE: CliState;
+export declare const DEFAULT_QUEUE: QueueStore;
+export declare const DEFAULT_WORKSPACE_BINDINGS: WorkspaceBindingStore;
+export declare const CALLBACK_TIMEOUT_MS = 120000;
+export declare const SENSITIVE_KEYS: string[];
+export declare const SAFE_ENV_KEYS: string[];

package/dist/core/constants.js

@@ -0,0 +1,78 @@
+export const CLI_NAME = "vp";
+export const CLI_CLIENT_ID = "vp-cli";
+export const PRODUCT_NAME = "VectorPlane";
+export const CONFIG_DIRECTORY_NAME = ".vectorplane";
+export const SESSION_FILE_NAME = "session.json";
+export const CONFIG_FILE_NAME = "config.json";
+export const DEVICE_FILE_NAME = "device.json";
+export const STATE_FILE_NAME = "state.json";
+export const QUEUE_FILE_NAME = "queue.json";
+export const WORKSPACE_BINDINGS_FILE_NAME = "workspaces.json";
+export const SNAPSHOTS_DIRECTORY_NAME = "snapshots";
+export const DEFAULT_PROFILE_NAME = "default";
+export const DEFAULT_PROFILE = {
+    name: DEFAULT_PROFILE_NAME,
+    apiBaseUrl: "https://api.vectorplane.io",
+    appBaseUrl: "https://app.vectorplane.io",
+    workspace: null,
+    orgId: null,
+    environment: "production",
+};
+export const DEFAULT_CONFIG = {
+    activeProfile: DEFAULT_PROFILE_NAME,
+    profiles: {
+        [DEFAULT_PROFILE_NAME]: DEFAULT_PROFILE,
+    },
+    callbackHost: "127.0.0.1",
+    callbackPort: 4217,
+    callbackPath: "/callback",
+    requestTimeoutMs: 15_000,
+    publicIpLookupTimeoutMs: 2_000,
+    debug: false,
+    telemetryEnabled: false,
+    queueMaxRetries: 5,
+    snapshotStoreLimit: 20,
+};
+export const DEFAULT_PROFILE_STATE = {
+    lastSyncAt: null,
+    lastWorkspace: null,
+    lastCommand: null,
+    lastSyncHash: null,
+    lastSyncStatus: null,
+    lastError: null,
+    lastSnapshotPath: null,
+    lastSessionId: null,
+};
+export const DEFAULT_STATE = {
+    activeProfile: DEFAULT_PROFILE_NAME,
+    profiles: {
+        [DEFAULT_PROFILE_NAME]: DEFAULT_PROFILE_STATE,
+    },
+};
+export const DEFAULT_QUEUE = {
+    items: [],
+};
+export const DEFAULT_WORKSPACE_BINDINGS = {
+    bindings: {},
+};
+export const CALLBACK_TIMEOUT_MS = 120_000;
+export const SENSITIVE_KEYS = ["token", "authorization", "refresh", "secret", "password", "cookie"];
+export const SAFE_ENV_KEYS = [
+    "SHELL",
+    "TERM",
+    "LANG",
+    "LC_ALL",
+    "LC_MESSAGES",
+    "COLORTERM",
+    "EDITOR",
+    "VISUAL",
+    "PWD",
+    "HOME",
+    "USER",
+    "USERNAME",
+    "PATH",
+    "WSL_DISTRO_NAME",
+    "CI",
+    "CODEX_ENV",
+];
+//# sourceMappingURL=constants.js.map

package/dist/core/env.d.ts

@@ -0,0 +1,2 @@
+import type { SafeEnvironmentVariable } from "../types/machine.js";
+export declare function collectSafeEnvironmentVariables(): SafeEnvironmentVariable[];

package/dist/core/env.js

@@ -0,0 +1,10 @@
+import { SAFE_ENV_KEYS } from "./constants.js";
+export function collectSafeEnvironmentVariables() {
+    return SAFE_ENV_KEYS
+        .map((key) => {
+        const value = process.env[key];
+        return value ? { key, value } : null;
+    })
+        .filter((entry) => entry !== null);
+}
+//# sourceMappingURL=env.js.map

package/dist/core/errors.d.ts

@@ -0,0 +1,18 @@
+export declare class CLIError extends Error {
+    readonly code: string;
+    readonly cause?: unknown | undefined;
+    constructor(message: string, code?: string, cause?: unknown | undefined);
+}
+export declare class AuthError extends CLIError {
+    constructor(message: string, cause?: unknown);
+}
+export declare class ConfigError extends CLIError {
+    constructor(message: string, cause?: unknown);
+}
+export declare class ApiError extends CLIError {
+    readonly status?: number | undefined;
+    constructor(message: string, status?: number | undefined, cause?: unknown);
+}
+export declare class ValidationError extends CLIError {
+    constructor(message: string, cause?: unknown);
+}

package/dist/core/errors.js

@@ -0,0 +1,37 @@
+export class CLIError extends Error {
+    code;
+    cause;
+    constructor(message, code = "cli_error", cause) {
+        super(message);
+        this.code = code;
+        this.cause = cause;
+        this.name = "CLIError";
+    }
+}
+export class AuthError extends CLIError {
+    constructor(message, cause) {
+        super(message, "auth_error", cause);
+        this.name = "AuthError";
+    }
+}
+export class ConfigError extends CLIError {
+    constructor(message, cause) {
+        super(message, "config_error", cause);
+        this.name = "ConfigError";
+    }
+}
+export class ApiError extends CLIError {
+    status;
+    constructor(message, status, cause) {
+        super(message, "api_error", cause);
+        this.status = status;
+        this.name = "ApiError";
+    }
+}
+export class ValidationError extends CLIError {
+    constructor(message, cause) {
+        super(message, "validation_error", cause);
+        this.name = "ValidationError";
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/core/git.d.ts

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