@vectorplane/ctrl-cli 0.1.0

package/dist/core/workspace.js

@@ -0,0 +1,121 @@
+import { access, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { constants as fsConstants } from "node:fs";
+import { createStableHash } from "./serializer.js";
+async function exists(filePath) {
+    try {
+        await access(filePath, fsConstants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function safeRead(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+async function detectMonorepo(rootPath, packageJsonRaw) {
+    if (packageJsonRaw) {
+        try {
+            const pkg = JSON.parse(packageJsonRaw);
+            if (Array.isArray(pkg.workspaces) || (pkg.workspaces && typeof pkg.workspaces === "object")) {
+                return true;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    const topLevel = await readdir(rootPath, { withFileTypes: true });
+    return topLevel.some((entry) => entry.isDirectory() && ["packages", "apps", "libs"].includes(entry.name));
+}
+function deriveSignals(content) {
+    const combined = `${content.packageJsonRaw}\n${content.tsconfigRaw}\n${content.wranglerRaw}\n${content.readmeRaw}\n${content.docsRaw}`.toLowerCase();
+    return {
+        hasCloudflareWorkers: combined.includes("wrangler") || combined.includes("durable object") || combined.includes("cloudflare worker"),
+        hasTypeScript: combined.includes("typescript") || combined.includes("\"tsc\""),
+        hasNode: combined.includes("\"node\"") || combined.includes("package.json"),
+        suggestsControlPlane: combined.includes("control plane") || combined.includes("governança") || combined.includes("orquestração"),
+        usesQueues: combined.includes("queue"),
+        usesDurableObjects: combined.includes("durable object"),
+        usesD1: combined.includes("d1"),
+        usesKv: combined.includes("kv"),
+        usesR2: combined.includes("r2"),
+        usesRestApi: combined.includes("rest"),
+        usesMcp: combined.includes("mcp"),
+    };
+}
+export async function collectWorkspaceContext(cwd, git) {
+    const rootPath = git.rootPath ?? cwd;
+    const packageJsonPath = path.join(rootPath, "package.json");
+    const tsconfigPath = path.join(rootPath, "tsconfig.json");
+    const wranglerPath = path.join(rootPath, "wrangler.toml");
+    const readmePath = path.join(rootPath, "README.md");
+    const docsPath = path.join(rootPath, "docs");
+    const [packageJsonRaw, tsconfigRaw, wranglerRaw, readmeRaw] = await Promise.all([
+        safeRead(packageJsonPath),
+        safeRead(tsconfigPath),
+        safeRead(wranglerPath),
+        safeRead(readmePath),
+    ]);
+    const docsEntries = await (async () => {
+        try {
+            const entries = await readdir(docsPath, { withFileTypes: true });
+            return entries.filter((entry) => entry.isFile()).map((entry) => entry.name).slice(0, 20).join("\n");
+        }
+        catch {
+            return "";
+        }
+    })();
+    const filePresence = {
+        AGENT_MD: await exists(path.join(rootPath, "AGENT.md")) || await exists(path.join(rootPath, "AGENTS.md")),
+        CLAUDE_MD: await exists(path.join(rootPath, "CLAUDE.md")),
+        README_MD: await exists(readmePath),
+        PACKAGE_JSON: await exists(packageJsonPath),
+        TSCONFIG_JSON: await exists(tsconfigPath),
+        WRANGLER_TOML: await exists(wranglerPath),
+        DOCKER_COMPOSE_YML: await exists(path.join(rootPath, "docker-compose.yml")),
+        ENV_EXAMPLE: await exists(path.join(rootPath, ".env.example")),
+    };
+    const derived = deriveSignals({ packageJsonRaw, tsconfigRaw, wranglerRaw, readmeRaw, docsRaw: docsEntries });
+    const isMonorepo = await detectMonorepo(rootPath, packageJsonRaw);
+    const importantFiles = [
+        { file: "README.md", present: filePresence.README_MD },
+        { file: "package.json", present: filePresence.PACKAGE_JSON },
+        { file: "tsconfig.json", present: filePresence.TSCONFIG_JSON },
+        { file: "wrangler.toml", present: filePresence.WRANGLER_TOML },
+        { file: "AGENT.md", present: filePresence.AGENT_MD },
+        { file: "AGENTS.md", present: filePresence.AGENT_MD },
+        { file: "CLAUDE.md", present: filePresence.CLAUDE_MD },
+        { file: "docker-compose.yml", present: filePresence.DOCKER_COMPOSE_YML },
+        { file: ".env.example", present: filePresence.ENV_EXAMPLE },
+    ]
+        .filter((entry) => entry.present)
+        .map((entry) => entry.file)
+        .slice(0, 12);
+    const snapshotHash = createStableHash({
+        rootPath,
+        filePresence,
+        signals: { ...derived, isGitRepository: git.isRepository, isMonorepo },
+        git,
+    });
+    return {
+        rootPath,
+        rootName: path.basename(rootPath),
+        collectedAt: new Date().toISOString(),
+        filePresence,
+        importantFiles,
+        signals: {
+            ...derived,
+            isGitRepository: git.isRepository,
+            isMonorepo,
+        },
+        snapshotHash,
+    };
+}
+//# sourceMappingURL=workspace.js.map

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,97 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { runBootstrapCommand } from "./commands/bootstrap.js";
+import { runConfigCommand } from "./commands/config.js";
+import { runContextCommand } from "./commands/context.js";
+import { runDoctorCommand } from "./commands/doctor.js";
+import { runEventCommand } from "./commands/event.js";
+import { runLoginCommand } from "./commands/login.js";
+import { runSessionCommand } from "./commands/session.js";
+import { runStatusCommand } from "./commands/status.js";
+import { runSyncCommand } from "./commands/sync.js";
+import { runWhoAmICommand } from "./commands/whoami.js";
+import { runWorkspaceCommand } from "./commands/workspace.js";
+import { CLIError } from "./core/errors.js";
+async function getCliVersion() {
+    const currentFile = fileURLToPath(import.meta.url);
+    const packagePath = path.resolve(path.dirname(currentFile), "../package.json");
+    const raw = await readFile(packagePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.version ?? "0.0.0";
+}
+function printHelp() {
+    process.stdout.write("VectorPlane Ctrl CLI\n");
+    process.stdout.write("Uso: vp <comando>\n");
+    process.stdout.write("\n");
+    process.stdout.write("Comandos principais:\n");
+    process.stdout.write("  login\n");
+    process.stdout.write("  sync [--force]\n");
+    process.stdout.write("  status\n");
+    process.stdout.write("  whoami\n");
+    process.stdout.write("  doctor\n");
+    process.stdout.write("  config <profile|get|set>\n");
+    process.stdout.write("  workspace <current|use|resolve|clear>\n");
+    process.stdout.write("  session <check-in|heartbeat|check-out>\n");
+    process.stdout.write("  context [--snapshot|--delivery]\n");
+    process.stdout.write("  bootstrap\n");
+    process.stdout.write("  event send <name> [--payload '{...}']\n");
+}
+export async function runCli(args) {
+    const [command, ...rest] = args;
+    if (!command || command === "--help" || command === "-h") {
+        printHelp();
+        return 0;
+    }
+    const cliVersion = await getCliVersion();
+    try {
+        switch (command) {
+            case "login":
+                return runLoginCommand(cliVersion, rest);
+            case "sync":
+                return runSyncCommand(cliVersion, rest);
+            case "status":
+                return runStatusCommand();
+            case "whoami":
+                return runWhoAmICommand(cliVersion);
+            case "doctor":
+                return runDoctorCommand(cliVersion);
+            case "config":
+                return runConfigCommand(rest);
+            case "workspace":
+                return runWorkspaceCommand(rest);
+            case "session":
+                return runSessionCommand(cliVersion, rest);
+            case "context":
+                return runContextCommand(cliVersion, rest);
+            case "bootstrap":
+                return runBootstrapCommand(cliVersion, rest);
+            case "event":
+                return runEventCommand(cliVersion, rest);
+            default:
+                throw new CLIError(`Comando desconhecido: ${command}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof CLIError) {
+            process.stderr.write(`VectorPlane: ${error.message}\n`);
+            return 1;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`VectorPlane: ${message}\n`);
+        return 1;
+    }
+}
+const entryArg = process.argv[1];
+if (entryArg && import.meta.url === pathToFileURL(entryArg).href) {
+    runCli(process.argv.slice(2))
+        .then((exitCode) => {
+        process.exitCode = exitCode;
+    })
+        .catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`VectorPlane: ${message}\n`);
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/types/api.d.ts

@@ -0,0 +1,61 @@
+import type { SnapshotPayload } from "./snapshot.js";
+export interface SyncRequest {
+    workspace: string;
+    command: "sync";
+    snapshot: SnapshotPayload;
+    hash: string;
+    sent_at: string;
+}
+export interface SyncResponse {
+    ok?: boolean;
+    workspace?: string;
+    received_at?: string;
+    [key: string]: unknown;
+}
+export interface EventRequest {
+    workspace: string;
+    event: string;
+    payload: Record<string, unknown>;
+    sent_at: string;
+}
+export interface ResolveWorkspaceRequest {
+    repoUrl: string;
+    orgId?: string;
+}
+export interface ResolveWorkspaceResponse {
+    id?: string;
+    workspaceId?: string;
+    slug?: string;
+    name?: string;
+    repoUrl?: string | null;
+    [key: string]: unknown;
+}
+export interface AgentSessionRequest {
+    workspaceId: string;
+    agentName: string;
+    agentType: string;
+    clientName: string;
+    clientInstanceId: string;
+    repoUrl?: string;
+    branch?: string | null;
+    commitSha?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentHeartbeatRequest {
+    sessionId: string;
+    clientInstanceId: string;
+    branch?: string | null;
+    commitSha?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentCheckoutRequest {
+    sessionId: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentSessionResponse {
+    id?: string;
+    sessionId?: string;
+    status?: string;
+    workspaceId?: string;
+    [key: string]: unknown;
+}

package/dist/types/api.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=api.js.map

package/dist/types/auth.d.ts

@@ -0,0 +1,36 @@
+import type { MachineContext, RuntimeContext } from "./machine.js";
+export interface AuthCodeExchangeRequest {
+    code: string;
+    client: "vp-cli";
+    device: MachineContext;
+    runtime: RuntimeContext;
+}
+export interface AuthTokenExchangeResponse {
+    access_token: string;
+    refresh_token: string;
+    workspace: string;
+    expires_in: number;
+    token_type: string;
+}
+export interface RefreshTokenRequest {
+    refresh_token: string;
+    client: "vp-cli";
+}
+export interface CurrentUserResponse {
+    id: string;
+    type: string;
+    email: string | null;
+    name: string | null;
+    orgIds: string[];
+    capabilities: string[];
+    isPlatformAdmin?: boolean;
+}
+export interface AuthSession {
+    accessToken: string;
+    refreshToken: string;
+    workspace: string;
+    tokenType: string;
+    expiresIn: number;
+    obtainedAt: string;
+    expiresAt: string;
+}

package/dist/types/auth.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=auth.js.map

package/dist/types/config.d.ts

@@ -0,0 +1,58 @@
+export type VectorPlaneEnvironment = "production" | "preview" | "self-hosted";
+export interface CliProfileConfig {
+    name: string;
+    apiBaseUrl: string;
+    appBaseUrl: string;
+    workspace: string | null;
+    orgId: string | null;
+    environment: VectorPlaneEnvironment;
+}
+export interface CliConfig {
+    activeProfile: string;
+    profiles: Record<string, CliProfileConfig>;
+    callbackHost: string;
+    callbackPort: number;
+    callbackPath: string;
+    requestTimeoutMs: number;
+    publicIpLookupTimeoutMs: number;
+    debug: boolean;
+    telemetryEnabled: boolean;
+    queueMaxRetries: number;
+    snapshotStoreLimit: number;
+}
+export interface CliProfileState {
+    lastSyncAt: string | null;
+    lastWorkspace: string | null;
+    lastCommand: string | null;
+    lastSyncHash: string | null;
+    lastSyncStatus: "success" | "queued" | "failed" | null;
+    lastError: string | null;
+    lastSnapshotPath: string | null;
+    lastSessionId: string | null;
+}
+export interface CliState {
+    activeProfile: string;
+    profiles: Record<string, CliProfileState>;
+}
+export interface WorkspaceBinding {
+    rootPath: string;
+    workspace: string;
+    repoUrl: string | null;
+    resolvedAt: string;
+    source: "manual" | "api-resolve" | "session";
+}
+export interface WorkspaceBindingStore {
+    bindings: Record<string, WorkspaceBinding>;
+}
+export interface PendingQueueItem {
+    id: string;
+    profile: string;
+    kind: "sync" | "event";
+    createdAt: string;
+    attempts: number;
+    lastError: string | null;
+    payload: Record<string, unknown>;
+}
+export interface QueueStore {
+    items: PendingQueueItem[];
+}

package/dist/types/config.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.js.map

package/dist/types/machine.d.ts

@@ -0,0 +1,49 @@
+export interface SafeEnvironmentVariable {
+    key: string;
+    value: string;
+}
+export interface NetworkInterfaceContext {
+    name: string;
+    family: string;
+    mac: string;
+    address: string;
+    internal: boolean;
+    cidr: string | null;
+}
+export interface RuntimeContext {
+    nodeVersion: string;
+    npmVersion: string | null;
+    cliVersion: string;
+    pid: number;
+    command: string;
+    args: string[];
+    shell: string | null;
+    safeEnv: SafeEnvironmentVariable[];
+}
+export interface DeviceIdentity {
+    machineId: string;
+    firstSeenAt: string;
+    lastSeenAt: string;
+}
+export interface MachineContext {
+    machineId: string;
+    hostname: string;
+    platform: NodeJS.Platform;
+    osRelease: string;
+    architecture: string;
+    kernelVersion: string;
+    username: string;
+    timezone: string;
+    locale: string;
+    shell: string | null;
+    currentDirectory: string;
+    homeDirectory: string;
+    cpuModel: string | null;
+    cpuCount: number;
+    loadAverage: number[];
+    memoryTotal: number;
+    memoryFree: number;
+    uptimeSeconds: number;
+    networkInterfaces: NetworkInterfaceContext[];
+    publicIp: string | null;
+}

package/dist/types/machine.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=machine.js.map

package/dist/types/snapshot.d.ts

@@ -0,0 +1,15 @@
+import type { GitContext, WorkspaceContext } from "./workspace.js";
+import type { MachineContext, RuntimeContext } from "./machine.js";
+export interface CommandMetadata {
+    name: string;
+    startedAt: string;
+    cwd: string;
+}
+export interface SnapshotPayload {
+    machine: MachineContext;
+    runtime: RuntimeContext;
+    workspace: WorkspaceContext;
+    git: GitContext;
+    command: CommandMetadata;
+    timestamp: string;
+}

package/dist/types/snapshot.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=snapshot.js.map

package/dist/types/workspace.d.ts

@@ -0,0 +1,44 @@
+export interface WorkspaceFilePresence {
+    AGENT_MD: boolean;
+    CLAUDE_MD: boolean;
+    README_MD: boolean;
+    PACKAGE_JSON: boolean;
+    TSCONFIG_JSON: boolean;
+    WRANGLER_TOML: boolean;
+    DOCKER_COMPOSE_YML: boolean;
+    ENV_EXAMPLE: boolean;
+}
+export interface WorkspaceSignals {
+    isGitRepository: boolean;
+    hasCloudflareWorkers: boolean;
+    hasTypeScript: boolean;
+    hasNode: boolean;
+    isMonorepo: boolean;
+    suggestsControlPlane: boolean;
+    usesQueues: boolean;
+    usesDurableObjects: boolean;
+    usesD1: boolean;
+    usesKv: boolean;
+    usesR2: boolean;
+    usesRestApi: boolean;
+    usesMcp: boolean;
+}
+export interface WorkspaceContext {
+    rootPath: string;
+    rootName: string;
+    collectedAt: string;
+    filePresence: WorkspaceFilePresence;
+    importantFiles: string[];
+    signals: WorkspaceSignals;
+    snapshotHash: string;
+}
+export interface GitContext {
+    isRepository: boolean;
+    rootPath: string | null;
+    branch: string | null;
+    commitHash: string | null;
+    remoteOrigin: string | null;
+    repositoryName: string | null;
+    hasLocalChanges: boolean;
+    statusSummary: string[];
+}

package/dist/types/workspace.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=workspace.js.map

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@vectorplane/ctrl-cli",
+  "version": "0.1.0",
+  "description": "Official VectorPlane CLI for secure local auth, workspace sync, agent sessions, and control plane operations.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "bin": {
+    "vp": "./bin/vp.js"
+  },
+  "files": [
+    "bin/vp.js",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/vector-plane/vectorplane-ctrl-cli.git"
+  },
+  "bugs": {
+    "url": "https://gitlab.com/vector-plane/vectorplane-ctrl-cli/-/issues"
+  },
+  "homepage": "https://gitlab.com/vector-plane/vectorplane-ctrl-cli#readme",
+  "funding": {
+    "type": "individual",
+    "url": "https://vectorplane.ai"
+  },
+  "engines": {
+    "node": ">=20.10.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc --noEmit -p tsconfig.json",
+    "dev": "node --enable-source-maps ./dist/index.js",
+    "pack:dry-run": "npm pack --dry-run",
+    "release:check": "npm run check && npm run build && npm run pack:dry-run",
+    "prepublishOnly": "npm run release:check",
+    "start": "node ./dist/index.js"
+  },
+  "keywords": [
+    "vectorplane",
+    "cli",
+    "control-plane",
+    "developer-tools",
+    "agents"
+  ],
+  "author": "VectorPlane",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "typescript": "^5.9.2"
+  }
+}