@vectorplane/ctrl-cli 0.1.12 → 0.1.14

package/dist/core/api.js

@@ -144,6 +144,21 @@ export class VectorPlaneApiClient {
             },
         }, this.timeoutMs, this.logger);
     }
+    async getWorkspaceSnapshotDiff(accessToken, workspaceId, params) {
+        const url = new URL(`${this.apiBaseUrl}/workspace/${workspaceId}/snapshot/diff`);
+        if (params.from) {
+            url.searchParams.set("from", params.from);
+        }
+        if (params.to) {
+            url.searchParams.set("to", params.to);
+        }
+        return requestJson(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
     async getWorkspaceDeliveryContext(accessToken, workspaceId) {
         return requestJson(`${this.apiBaseUrl}/cli/workspace/${workspaceId}/delivery-context`, {
             method: "GET",
@@ -202,6 +217,29 @@ export class VectorPlaneApiClient {
             body: JSON.stringify(payload),
         }, this.timeoutMs, this.logger);
     }
+    async listWorkspaceWebhooks(accessToken, workspaceRef) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/webhooks`, {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
+    async createWorkspaceWebhook(accessToken, workspaceRef, payload) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/webhooks`, {
+            method: "POST",
+            headers: authHeaders(accessToken),
+            body: JSON.stringify(payload),
+        }, this.timeoutMs, this.logger);
+    }
+    async deleteWorkspaceWebhook(accessToken, workspaceRef, webhookId) {
+        return requestJson(`${this.apiBaseUrl}/workspace/${workspaceRef}/webhooks/${webhookId}`, {
+            method: "DELETE",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+            },
+        }, this.timeoutMs, this.logger);
+    }
     async listMemoryDrafts(accessToken, workspaceRef, status) {
         const url = new URL(`${this.apiBaseUrl}/cli/workspace/${workspaceRef}/memory-drafts`);
         if (status) {
@@ -421,5 +459,79 @@ export class VectorPlaneApiClient {
             method: "GET",
         }, this.timeoutMs, this.logger);
     }
+    async streamWorkspaceEvents(accessToken, workspaceRef, params) {
+        const url = new URL(`${this.apiBaseUrl}/workspace/${workspaceRef}/events/stream`);
+        if (params.taskId) {
+            url.searchParams.set("task_id", params.taskId);
+        }
+        if (params.types && params.types.length > 0) {
+            url.searchParams.set("types", params.types.join(","));
+        }
+        this.logger.debug("http_stream_open", { url: url.toString() });
+        const response = await fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${accessToken}`,
+                "Accept": "text/event-stream",
+            },
+            signal: params.signal,
+        });
+        if (!response.ok || !response.body) {
+            const body = await parseBody(response);
+            const message = typeof body === "string" ? body : `HTTP ${response.status}`;
+            throw new ApiError(message, response.status, body);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const emitFrame = (frame) => {
+            const lines = frame.split("\n");
+            let eventName = "message";
+            const dataLines = [];
+            for (const line of lines) {
+                if (line.startsWith("event:")) {
+                    eventName = line.slice(6).trim();
+                    continue;
+                }
+                if (line.startsWith("data:")) {
+                    dataLines.push(line.slice(5).trim());
+                }
+            }
+            if (dataLines.length === 0) {
+                return;
+            }
+            try {
+                const payload = JSON.parse(dataLines.join("\n"));
+                params.onEvent({
+                    type: eventName,
+                    workspaceId: payload.workspaceId,
+                    taskId: payload.taskId ?? null,
+                    stepId: payload.stepId ?? null,
+                    timestamp: payload.timestamp,
+                    summary: payload.summary ?? null,
+                });
+            }
+            catch (error) {
+                this.logger.debug("http_stream_frame_ignored", {
+                    reason: error instanceof Error ? error.message : "invalid_json",
+                    eventName,
+                });
+            }
+        };
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let separatorIndex = buffer.indexOf("\n\n");
+            while (separatorIndex >= 0) {
+                const frame = buffer.slice(0, separatorIndex);
+                buffer = buffer.slice(separatorIndex + 2);
+                emitFrame(frame);
+                separatorIndex = buffer.indexOf("\n\n");
+            }
+        }
+    }
 }
 //# sourceMappingURL=api.js.map

package/dist/core/auth.d.ts

@@ -1,4 +1,4 @@
-import type { CliConfig, CliProfileConfig } from "../types/config.js";
+import type { CliConfig, CliLoginMode, 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";
@@ -13,5 +13,5 @@ export declare function runLoginFlow(params: {
     device: DeviceIdentity;
     apiClient: VectorPlaneApiClient;
     logger: Logger;
-    noBrowser?: boolean;
+    loginMode: CliLoginMode;
 }): Promise<AuthSession>;

package/dist/core/auth.js

@@ -25,48 +25,118 @@ export async function openBrowser(url) {
         });
     });
 }
+function printLoginInstructions(loginMode, loginUrl, logger) {
+    if (loginMode === "browser") {
+        logger.info("abrindo navegador para autenticação...");
+        return;
+    }
+    if (loginMode === "manual") {
+        logger.info("login manual habilitado. abra a URL abaixo no navegador:");
+        process.stdout.write(`${loginUrl}\n`);
+        return;
+    }
+    logger.info("login device-like habilitado. use a URL abaixo em qualquer navegador confiável:");
+    process.stdout.write(`${loginUrl}\n`);
+}
+async function waitForCallbackCode(callbackServer, timeoutMs) {
+    try {
+        const callback = await callbackServer.waitForCallback(timeoutMs);
+        return callback.code;
+    }
+    catch (error) {
+        throw new AuthError("Falha no callback local do login do CLI.", error);
+    }
+}
+async function waitForAuthorizedAttempt(params) {
+    const startedAt = Date.now();
+    let announcedAuthorization = false;
+    while (Date.now() - startedAt < params.timeoutMs) {
+        let status;
+        try {
+            status = await params.apiClient.getLoginAttemptStatus(params.attemptId, params.pollToken);
+        }
+        catch (error) {
+            throw new AuthError("Falha ao acompanhar a autorização do login do CLI por polling.", error);
+        }
+        const code = pickAuthorizedCode(status);
+        if (code) {
+            return code;
+        }
+        if (status.status === "authorized" && !announcedAuthorization) {
+            announcedAuthorization = true;
+            params.logger.info("autorização recebida pela API. finalizando sessão...");
+        }
+        await delay(LOGIN_ATTEMPT_POLL_INTERVAL_MS);
+    }
+    throw new AuthError("Tempo esgotado aguardando a confirmação do login do CLI.");
+}
+function pickAuthorizedCode(status) {
+    if ((status.status === "authorized" || status.status === "completed") && typeof status.code === "string" && status.code.length > 0) {
+        return status.code;
+    }
+    return null;
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
 export async function runLoginFlow(params) {
     const state = generateLoginState();
-    const callbackServer = await createCallbackServer(params.config.callbackHost, params.config.callbackPort, params.config.callbackPath, state);
+    const useLoopback = params.loginMode !== "device";
+    const callbackServer = useLoopback
+        ? await createCallbackServer(params.config.callbackHost, params.config.callbackPort, params.config.callbackPath, state)
+        : null;
     try {
+        const redirectUri = callbackServer?.callbackUrl ?? `http://127.0.0.1/disabled-device-flow/${state}`;
         const loginAttempt = await params.apiClient.createLoginAttempt({
-            redirectUri: callbackServer.callbackUrl,
+            redirectUri,
             state,
             client: CLI_CLIENT_ID,
         });
         const loginUrl = loginAttempt.loginUrl;
-        if (params.noBrowser) {
-            params.logger.info("login manual habilitado. abra a URL abaixo no navegador:");
-            process.stdout.write(`${loginUrl}\n`);
-        }
-        else {
-            params.logger.info("abrindo navegador para autenticação...");
+        printLoginInstructions(params.loginMode, loginUrl, params.logger);
+        if (params.loginMode === "browser") {
             const opened = await openBrowser(loginUrl);
             if (!opened) {
-                params.logger.warn("não foi possível abrir o navegador automaticamente.");
+                params.logger.warn("não foi possível abrir o navegador automaticamente. continue pela URL abaixo.");
                 process.stdout.write(`${loginUrl}\n`);
             }
         }
         params.logger.info("aguardando confirmação...");
-        const code = await Promise.any([
-            callbackServer.waitForCallback(CALLBACK_TIMEOUT_MS).then((callback) => callback.code),
-            waitForAuthorizedAttempt({
+        const code = params.loginMode === "device"
+            ? await waitForAuthorizedAttempt({
                 apiClient: params.apiClient,
                 attemptId: loginAttempt.attemptId,
                 pollToken: loginAttempt.pollToken,
                 timeoutMs: CALLBACK_TIMEOUT_MS,
                 logger: params.logger,
-            }),
-        ]).catch((error) => {
-            throw new AuthError("Não foi possível concluir o login do CLI.", error);
-        });
+            })
+            : await Promise.any([
+                waitForCallbackCode(callbackServer, CALLBACK_TIMEOUT_MS),
+                waitForAuthorizedAttempt({
+                    apiClient: params.apiClient,
+                    attemptId: loginAttempt.attemptId,
+                    pollToken: loginAttempt.pollToken,
+                    timeoutMs: CALLBACK_TIMEOUT_MS,
+                    logger: params.logger,
+                }),
+            ]).catch((error) => {
+                throw new AuthError("Não foi possível concluir o login do CLI.", error);
+            });
         const payload = {
             code,
             client: CLI_CLIENT_ID,
             device: params.machine,
             runtime: params.runtime,
         };
-        const tokenResponse = await params.apiClient.exchangeToken(payload);
+        let tokenResponse;
+        try {
+            tokenResponse = await params.apiClient.exchangeToken(payload);
+        }
+        catch (error) {
+            throw new AuthError("Falha na troca do código do CLI por sessão autenticada.", error);
+        }
         if (!tokenResponse.access_token || !tokenResponse.refresh_token) {
             throw new AuthError("A API retornou uma sessão inválida.");
         }
@@ -80,38 +150,11 @@ export async function runLoginFlow(params) {
             obtainedAt: new Date().toISOString(),
             expiresAt: new Date(Date.now() + tokenResponse.expires_in * 1000).toISOString(),
             lastRefreshAt: null,
+            deviceId: params.device.machineId,
         };
     }
     finally {
-        await callbackServer.close();
+        await callbackServer?.close();
     }
 }
-async function waitForAuthorizedAttempt(params) {
-    const startedAt = Date.now();
-    let announcedAuthorization = false;
-    while (Date.now() - startedAt < params.timeoutMs) {
-        const status = await params.apiClient.getLoginAttemptStatus(params.attemptId, params.pollToken);
-        const code = pickAuthorizedCode(status);
-        if (code) {
-            return code;
-        }
-        if (status.status === "authorized" && !announcedAuthorization) {
-            announcedAuthorization = true;
-            params.logger.info("autorização recebida pela API. finalizando sessão...");
-        }
-        await delay(LOGIN_ATTEMPT_POLL_INTERVAL_MS);
-    }
-    throw new AuthError("Tempo esgotado aguardando a confirmação do login do CLI.");
-}
-function pickAuthorizedCode(status) {
-    if ((status.status === "authorized" || status.status === "completed") && typeof status.code === "string" && status.code.length > 0) {
-        return status.code;
-    }
-    return null;
-}
-function delay(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
 //# sourceMappingURL=auth.js.map

package/dist/core/constants.js

@@ -38,9 +38,14 @@ export const DEFAULT_CONFIG = {
         requireSecureStorage: false,
         disableFileSessionFallback: false,
         requireManualLogin: false,
+        requireDeviceLogin: false,
         blockPublicIpLookup: false,
         blockMacAddressCollection: false,
         blockUsernameCollection: false,
+        blockNetworkInterfaceCollection: false,
+        blockCurrentDirectoryCollection: false,
+        blockHomeDirectoryCollection: false,
+        blockShellCollection: false,
     },
 };
 export const DEFAULT_PROFILE_STATE = {
@@ -53,8 +58,10 @@ export const DEFAULT_PROFILE_STATE = {
     lastSnapshotPath: null,
     lastSessionId: null,
     lastLoginAt: null,
+    lastLoginMethod: null,
     lastRefreshAt: null,
     lastLogoutAt: null,
+    lastRemoteRevokeAt: null,
     storageBackend: null,
     storageProtected: null,
     lastAuthFailure: null,
@@ -74,7 +81,20 @@ export const DEFAULT_WORKSPACE_BINDINGS = {
 };
 export const CALLBACK_TIMEOUT_MS = 120_000;
 export const LOGIN_ATTEMPT_POLL_INTERVAL_MS = 1_000;
-export const SENSITIVE_KEYS = ["token", "authorization", "refresh", "secret", "password", "cookie"];
+export const SENSITIVE_KEYS = [
+    "token",
+    "authorization",
+    "refresh",
+    "secret",
+    "password",
+    "cookie",
+    "set-cookie",
+    "session",
+    "machineid",
+    "deviceid",
+    "polltoken",
+    "code",
+];
 export const SAFE_ENV_KEYS = [
     "SHELL",
     "TERM",

package/dist/core/machine.d.ts

@@ -1,4 +1,11 @@
-import type { CliConfig } from "../types/config.js";
+import type { CliConfig, CliPolicyConfig, MachinePrivacyProfile } from "../types/config.js";
 import type { DeviceIdentity, MachineContext, RuntimeContext } from "../types/machine.js";
+export interface ExecutionEnvironmentAssessment {
+    risks: string[];
+    recommendedLoginMode: "browser" | "manual" | "device";
+    loopbackLikelySafe: boolean;
+}
+export declare function assessExecutionEnvironment(): ExecutionEnvironmentAssessment;
+export declare function describePrivacyEnvelope(profile: MachinePrivacyProfile, policy: CliPolicyConfig): Record<string, boolean>;
 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

@@ -30,7 +30,7 @@ async function detectPublicIp(timeoutMs) {
         clearTimeout(timer);
     }
 }
-function collectNetworkInterfaces() {
+function collectNetworkInterfaces(includeMacAddress, includeAddresses) {
     const interfaces = os.networkInterfaces();
     const results = [];
     for (const [name, entries] of Object.entries(interfaces)) {
@@ -38,14 +38,48 @@ function collectNetworkInterfaces() {
             results.push({
                 name,
                 family: entry.family,
-                mac: entry.mac,
-                address: entry.address,
+                mac: includeMacAddress ? entry.mac : null,
+                address: includeAddresses ? entry.address : null,
                 internal: entry.internal,
-                cidr: entry.cidr ?? null,
+                cidr: includeAddresses ? (entry.cidr ?? null) : null,
             });
         }
     }
-    return results.sort((left, right) => left.name.localeCompare(right.name) || left.address.localeCompare(right.address));
+    return results.sort((left, right) => left.name.localeCompare(right.name) || String(left.address).localeCompare(String(right.address)));
+}
+export function assessExecutionEnvironment() {
+    const risks = [];
+    if (process.env.WSL_DISTRO_NAME) {
+        risks.push("wsl");
+    }
+    if (process.env.SSH_CONNECTION || process.env.SSH_CLIENT) {
+        risks.push("ssh");
+    }
+    if (process.env.CI === "true") {
+        risks.push("ci");
+    }
+    if (process.env.CONTAINER || process.env.DOCKER_CONTAINER || process.env.KUBERNETES_SERVICE_HOST) {
+        risks.push("container");
+    }
+    const loopbackLikelySafe = risks.length === 0;
+    const recommendedLoginMode = loopbackLikelySafe
+        ? "browser"
+        : risks.includes("ssh") || risks.includes("container") || risks.includes("ci")
+            ? "device"
+            : "manual";
+    return { risks, recommendedLoginMode, loopbackLikelySafe };
+}
+export function describePrivacyEnvelope(profile, policy) {
+    return {
+        username: !policy.blockUsernameCollection && profile !== "minimal",
+        publicIp: !policy.blockPublicIpLookup && profile !== "minimal",
+        networkInterfaces: !policy.blockNetworkInterfaceCollection && profile !== "minimal",
+        networkAddresses: profile === "enterprise" && !policy.blockNetworkInterfaceCollection,
+        macAddress: profile === "enterprise" && !policy.blockMacAddressCollection,
+        currentDirectory: !policy.blockCurrentDirectoryCollection && profile !== "minimal",
+        homeDirectory: !policy.blockHomeDirectoryCollection && profile === "enterprise",
+        shell: !policy.blockShellCollection && profile !== "minimal",
+    };
 }
 export async function collectRuntimeContext(cliVersion, command, args) {
     return {
@@ -62,14 +96,11 @@ export async function collectRuntimeContext(cliVersion, command, args) {
 export async function collectMachineContext(identity, config) {
     const cpus = os.cpus();
     const privacyProfile = config.profiles[config.activeProfile]?.machinePrivacyProfile ?? "standard";
-    const collectPublicIp = !config.policy.blockPublicIpLookup && privacyProfile !== "minimal";
-    const includeMacAddress = !config.policy.blockMacAddressCollection && privacyProfile === "enterprise";
-    const includeUsername = !config.policy.blockUsernameCollection && privacyProfile !== "minimal";
-    const networkInterfaces = collectNetworkInterfaces().map((entry) => ({
-        ...entry,
-        mac: includeMacAddress ? entry.mac : null,
-    }));
-    const publicIp = collectPublicIp ? await detectPublicIp(config.publicIpLookupTimeoutMs) : null;
+    const envelope = describePrivacyEnvelope(privacyProfile, config.policy);
+    const publicIp = envelope.publicIp ? await detectPublicIp(config.publicIpLookupTimeoutMs) : null;
+    const networkInterfaces = envelope.networkInterfaces
+        ? collectNetworkInterfaces(envelope.macAddress, envelope.networkAddresses)
+        : [];
     return {
         machineId: identity.machineId,
         hostname: os.hostname(),
@@ -77,19 +108,19 @@ export async function collectMachineContext(identity, config) {
         osRelease: os.release(),
         architecture: os.arch(),
         kernelVersion: os.version(),
-        username: includeUsername ? os.userInfo().username : null,
+        username: envelope.username ? os.userInfo().username : null,
         timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
         locale: Intl.DateTimeFormat().resolvedOptions().locale,
-        shell: process.env.SHELL ?? null,
-        currentDirectory: process.cwd(),
-        homeDirectory: os.homedir(),
+        shell: envelope.shell ? (process.env.SHELL ?? null) : null,
+        currentDirectory: envelope.currentDirectory ? process.cwd() : null,
+        homeDirectory: envelope.homeDirectory ? os.homedir() : null,
         cpuModel: cpus[0]?.model ?? null,
         cpuCount: cpus.length,
         loadAverage: os.loadavg(),
         memoryTotal: os.totalmem(),
         memoryFree: os.freemem(),
         uptimeSeconds: os.uptime(),
-        networkInterfaces: privacyProfile === "minimal" ? [] : networkInterfaces,
+        networkInterfaces,
         publicIp,
         privacyProfile,
     };

package/dist/index.js

@@ -31,17 +31,17 @@ function printHelp() {
     process.stdout.write("\n");
     process.stdout.write("Comandos principais:\n");
     process.stdout.write("  init [--agent <tipo>] [--workspace <workspace>] [--force]\n");
-    process.stdout.write("  login [--no-browser|--manual]\n");
+    process.stdout.write("  login [--no-browser|--manual|--device]\n");
     process.stdout.write("  logout\n");
     process.stdout.write("  sync [--force]\n");
     process.stdout.write("  status\n");
-    process.stdout.write("  task <run|templates|list|inspect|claim|execute|daemon|approve|reject|delegate|step-update|handoff|observability|health>\n");
+    process.stdout.write("  task <run|templates|list|inspect|watch|claim|execute|daemon|approve|reject|delegate|step-update|handoff|observability|health>\n");
     process.stdout.write("  registry <list|register|update|deactivate>\n");
     process.stdout.write("  whoami\n");
-    process.stdout.write("  doctor\n");
+    process.stdout.write("  doctor [--policy]\n");
     process.stdout.write("  draft <create|list>\n");
     process.stdout.write("  config <profile|get|set>\n");
-    process.stdout.write("  workspace <current|use|resolve|clear>\n");
+    process.stdout.write("  workspace <current|use|resolve|clear|policy|webhook>\n");
     process.stdout.write("  session <check-in|heartbeat|check-out>\n");
     process.stdout.write("  context [--snapshot|--delivery]\n");
     process.stdout.write("  bootstrap\n");
@@ -73,7 +73,7 @@ export async function runCli(args) {
             case "whoami":
                 return runWhoAmICommand(cliVersion);
             case "doctor":
-                return runDoctorCommand(cliVersion);
+                return runDoctorCommand(cliVersion, rest);
             case "draft":
                 return runDraftCommand(cliVersion, rest);
             case "config":

package/dist/types/api.d.ts

@@ -88,6 +88,23 @@ export interface WorkspacePolicyRuleRecord {
     updatedAt: string;
     [key: string]: unknown;
 }
+export type WorkspaceWebhookEventType = "task.created" | "task.blocked" | "task.completed" | "task.approval_required" | "health.degraded";
+export interface WorkspaceWebhookRecord {
+    id: string;
+    orgId: string;
+    workspaceId: string;
+    name: string;
+    targetUrl: string;
+    secretPreview: string;
+    events: WorkspaceWebhookEventType[];
+    enabled: boolean;
+    lastDeliveryAt: string | null;
+    lastDeliveryStatus: "delivered" | "failed" | null;
+    lastError: string | null;
+    createdAt: string;
+    updatedAt: string;
+    [key: string]: unknown;
+}
 export interface AgentRegistryRecord {
     id: string;
     orgId: string | null;
@@ -291,3 +308,32 @@ export interface TaskObservabilityRecord {
     timeline?: Array<Record<string, unknown>>;
     [key: string]: unknown;
 }
+export interface WorkspaceStreamEventRecord {
+    type: string;
+    workspaceId: string;
+    taskId?: string | null;
+    stepId?: string | null;
+    timestamp: string;
+    summary?: Record<string, unknown> | null;
+}
+export interface WorkspaceSnapshotDiffRecord {
+    workspaceId: string;
+    from: {
+        reference: string;
+        version: number;
+        generatedAt: string;
+    };
+    to: {
+        reference: string;
+        version: number;
+        generatedAt: string;
+    };
+    summary: Record<string, {
+        added: number;
+        removed: number;
+        modified: number;
+    }>;
+    added: Record<string, Array<Record<string, unknown>>>;
+    removed: Record<string, Array<Record<string, unknown>>>;
+    modified: Record<string, Array<Record<string, unknown>>>;
+}

package/dist/types/auth.d.ts

@@ -56,4 +56,5 @@ export interface AuthSession {
     obtainedAt: string;
     expiresAt: string;
     lastRefreshAt: string | null;
+    deviceId?: string | null;
 }

package/dist/types/config.d.ts

@@ -1,13 +1,19 @@
 export type VectorPlaneEnvironment = "production" | "preview" | "self-hosted";
 export type MachinePrivacyProfile = "standard" | "minimal" | "enterprise";
 export type SessionStorageBackend = "system" | "file";
+export type CliLoginMode = "browser" | "manual" | "device";
 export interface CliPolicyConfig {
     requireSecureStorage: boolean;
     disableFileSessionFallback: boolean;
     requireManualLogin: boolean;
+    requireDeviceLogin: boolean;
     blockPublicIpLookup: boolean;
     blockMacAddressCollection: boolean;
     blockUsernameCollection: boolean;
+    blockNetworkInterfaceCollection: boolean;
+    blockCurrentDirectoryCollection: boolean;
+    blockHomeDirectoryCollection: boolean;
+    blockShellCollection: boolean;
 }
 export interface CliProfileConfig {
     name: string;
@@ -43,8 +49,10 @@ export interface CliProfileState {
     lastSnapshotPath: string | null;
     lastSessionId: string | null;
     lastLoginAt: string | null;
+    lastLoginMethod: CliLoginMode | null;
     lastRefreshAt: string | null;
     lastLogoutAt: string | null;
+    lastRemoteRevokeAt: string | null;
     storageBackend: SessionStorageBackend | null;
     storageProtected: boolean | null;
     lastAuthFailure: string | null;

package/dist/types/machine.d.ts

@@ -6,7 +6,7 @@ export interface NetworkInterfaceContext {
     name: string;
     family: string;
     mac: string | null;
-    address: string;
+    address: string | null;
     internal: boolean;
     cidr: string | null;
 }
@@ -36,8 +36,8 @@ export interface MachineContext {
     timezone: string;
     locale: string;
     shell: string | null;
-    currentDirectory: string;
-    homeDirectory: string;
+    currentDirectory: string | null;
+    homeDirectory: string | null;
     cpuModel: string | null;
     cpuCount: number;
     loadAverage: number[];