antigravity-auth 1.6.0 → 1.7.0

package/dist/plugin/recovery/storage.js

@@ -1,340 +0,0 @@
-/**
- * Storage utilities for reading OpenCode's session data.
- *
- * Based on oh-my-opencode/src/hooks/session-recovery/storage.ts
- */
-import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { MESSAGE_STORAGE, PART_STORAGE, THINKING_TYPES, META_TYPES } from "./constants";
-// =============================================================================
-// =============================================================================
-export function generatePartId() {
-    const timestamp = Date.now().toString(16);
-    const random = Math.random().toString(36).substring(2, 10);
-    return `prt_${timestamp}${random}`;
-}
-// =============================================================================
-// =============================================================================
-export function getMessageDir(sessionID) {
-    if (!existsSync(MESSAGE_STORAGE))
-        return "";
-    const directPath = join(MESSAGE_STORAGE, sessionID);
-    if (existsSync(directPath)) {
-        return directPath;
-    }
-    try {
-        for (const dir of readdirSync(MESSAGE_STORAGE)) {
-            const sessionPath = join(MESSAGE_STORAGE, dir, sessionID);
-            if (existsSync(sessionPath)) {
-                return sessionPath;
-            }
-        }
-    }
-    catch {
-    }
-    return "";
-}
-// =============================================================================
-// =============================================================================
-export function readMessages(sessionID) {
-    const messageDir = getMessageDir(sessionID);
-    if (!messageDir || !existsSync(messageDir))
-        return [];
-    const messages = [];
-    try {
-        for (const file of readdirSync(messageDir)) {
-            if (!file.endsWith(".json"))
-                continue;
-            try {
-                const content = readFileSync(join(messageDir, file), "utf-8");
-                messages.push(JSON.parse(content));
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    catch {
-        return [];
-    }
-    return messages.sort((a, b) => {
-        const aTime = a.time?.created ?? 0;
-        const bTime = b.time?.created ?? 0;
-        if (aTime !== bTime)
-            return aTime - bTime;
-        return a.id.localeCompare(b.id);
-    });
-}
-// =============================================================================
-// =============================================================================
-export function readParts(messageID) {
-    const partDir = join(PART_STORAGE, messageID);
-    if (!existsSync(partDir))
-        return [];
-    const parts = [];
-    try {
-        for (const file of readdirSync(partDir)) {
-            if (!file.endsWith(".json"))
-                continue;
-            try {
-                const content = readFileSync(join(partDir, file), "utf-8");
-                parts.push(JSON.parse(content));
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    catch {
-        return [];
-    }
-    return parts;
-}
-// =============================================================================
-// =============================================================================
-export function hasContent(part) {
-    if (THINKING_TYPES.has(part.type))
-        return false;
-    if (META_TYPES.has(part.type))
-        return false;
-    if (part.type === "text") {
-        const textPart = part;
-        return !!(textPart.text?.trim());
-    }
-    if (part.type === "tool" || part.type === "tool_use") {
-        return true;
-    }
-    if (part.type === "tool_result") {
-        return true;
-    }
-    return false;
-}
-export function messageHasContent(messageID) {
-    const parts = readParts(messageID);
-    return parts.some(hasContent);
-}
-// =============================================================================
-// =============================================================================
-export function injectTextPart(sessionID, messageID, text) {
-    const partDir = join(PART_STORAGE, messageID);
-    try {
-        if (!existsSync(partDir)) {
-            mkdirSync(partDir, { recursive: true });
-        }
-        const partId = generatePartId();
-        const part = {
-            id: partId,
-            sessionID,
-            messageID,
-            type: "text",
-            text,
-            synthetic: true,
-        };
-        writeFileSync(join(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// =============================================================================
-// =============================================================================
-export function findMessagesWithThinkingBlocks(sessionID) {
-    const messages = readMessages(sessionID);
-    const result = [];
-    for (const msg of messages) {
-        if (msg.role !== "assistant")
-            continue;
-        const parts = readParts(msg.id);
-        const hasThinking = parts.some((p) => THINKING_TYPES.has(p.type));
-        if (hasThinking) {
-            result.push(msg.id);
-        }
-    }
-    return result;
-}
-export function findMessagesWithThinkingOnly(sessionID) {
-    const messages = readMessages(sessionID);
-    const result = [];
-    for (const msg of messages) {
-        if (msg.role !== "assistant")
-            continue;
-        const parts = readParts(msg.id);
-        if (parts.length === 0)
-            continue;
-        const hasThinking = parts.some((p) => THINKING_TYPES.has(p.type));
-        const hasTextContent = parts.some(hasContent);
-        if (hasThinking && !hasTextContent) {
-            result.push(msg.id);
-        }
-    }
-    return result;
-}
-export function findMessagesWithOrphanThinking(sessionID) {
-    const messages = readMessages(sessionID);
-    const result = [];
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        if (!msg || msg.role !== "assistant")
-            continue;
-        const parts = readParts(msg.id);
-        if (parts.length === 0)
-            continue;
-        const sortedParts = [...parts].sort((a, b) => a.id.localeCompare(b.id));
-        const firstPart = sortedParts[0];
-        if (!firstPart)
-            continue;
-        const firstIsThinking = THINKING_TYPES.has(firstPart.type);
-        if (!firstIsThinking) {
-            result.push(msg.id);
-        }
-    }
-    return result;
-}
-export function prependThinkingPart(sessionID, messageID) {
-    const partDir = join(PART_STORAGE, messageID);
-    try {
-        if (!existsSync(partDir)) {
-            mkdirSync(partDir, { recursive: true });
-        }
-        const partId = "prt_0000000000_thinking";
-        const part = {
-            id: partId,
-            sessionID,
-            messageID,
-            type: "thinking",
-            thinking: "",
-            synthetic: true,
-        };
-        writeFileSync(join(partDir, `${partId}.json`), JSON.stringify(part, null, 2));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function stripThinkingParts(messageID) {
-    const partDir = join(PART_STORAGE, messageID);
-    if (!existsSync(partDir))
-        return false;
-    let anyRemoved = false;
-    try {
-        for (const file of readdirSync(partDir)) {
-            if (!file.endsWith(".json"))
-                continue;
-            try {
-                const filePath = join(partDir, file);
-                const content = readFileSync(filePath, "utf-8");
-                const part = JSON.parse(content);
-                if (THINKING_TYPES.has(part.type)) {
-                    unlinkSync(filePath);
-                    anyRemoved = true;
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    catch {
-        return false;
-    }
-    return anyRemoved;
-}
-// =============================================================================
-// =============================================================================
-export function findEmptyMessages(sessionID) {
-    const messages = readMessages(sessionID);
-    const emptyIds = [];
-    for (const msg of messages) {
-        if (!messageHasContent(msg.id)) {
-            emptyIds.push(msg.id);
-        }
-    }
-    return emptyIds;
-}
-export function findEmptyMessageByIndex(sessionID, targetIndex) {
-    const messages = readMessages(sessionID);
-    const indicesToTry = [targetIndex, targetIndex - 1, targetIndex - 2];
-    for (const idx of indicesToTry) {
-        if (idx < 0 || idx >= messages.length)
-            continue;
-        const targetMsg = messages[idx];
-        if (!targetMsg)
-            continue;
-        if (!messageHasContent(targetMsg.id)) {
-            return targetMsg.id;
-        }
-    }
-    return null;
-}
-export function findMessageByIndexNeedingThinking(sessionID, targetIndex) {
-    const messages = readMessages(sessionID);
-    if (targetIndex < 0 || targetIndex >= messages.length)
-        return null;
-    const targetMsg = messages[targetIndex];
-    if (!targetMsg || targetMsg.role !== "assistant")
-        return null;
-    const parts = readParts(targetMsg.id);
-    if (parts.length === 0)
-        return null;
-    const sortedParts = [...parts].sort((a, b) => a.id.localeCompare(b.id));
-    const firstPart = sortedParts[0];
-    if (!firstPart)
-        return null;
-    const firstIsThinking = THINKING_TYPES.has(firstPart.type);
-    if (!firstIsThinking) {
-        return targetMsg.id;
-    }
-    return null;
-}
-export function replaceEmptyTextParts(messageID, replacementText) {
-    const partDir = join(PART_STORAGE, messageID);
-    if (!existsSync(partDir))
-        return false;
-    let anyReplaced = false;
-    try {
-        for (const file of readdirSync(partDir)) {
-            if (!file.endsWith(".json"))
-                continue;
-            try {
-                const filePath = join(partDir, file);
-                const content = readFileSync(filePath, "utf-8");
-                const part = JSON.parse(content);
-                if (part.type === "text") {
-                    const textPart = part;
-                    if (!textPart.text?.trim()) {
-                        textPart.text = replacementText;
-                        textPart.synthetic = true;
-                        writeFileSync(filePath, JSON.stringify(textPart, null, 2));
-                        anyReplaced = true;
-                    }
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    catch {
-        return false;
-    }
-    return anyReplaced;
-}
-export function findMessagesWithEmptyTextParts(sessionID) {
-    const messages = readMessages(sessionID);
-    const result = [];
-    for (const msg of messages) {
-        const parts = readParts(msg.id);
-        const hasEmptyTextPart = parts.some((p) => {
-            if (p.type !== "text")
-                return false;
-            const textPart = p;
-            return !textPart.text?.trim();
-        });
-        if (hasEmptyTextPart) {
-            result.push(msg.id);
-        }
-    }
-    return result;
-}

package/dist/plugin/recovery/types.d.ts

@@ -1,115 +0,0 @@
-/**
- * Types for session recovery.
- *
- * Based on oh-my-opencode/src/hooks/session-recovery/types.ts
- */
-export type ThinkingPartType = "thinking" | "redacted_thinking" | "reasoning";
-export type MetaPartType = "step-start" | "step-finish";
-export type ContentPartType = "text" | "tool" | "tool_use" | "tool_result";
-export interface StoredMessageMeta {
-    id: string;
-    sessionID: string;
-    role: "user" | "assistant";
-    parentID?: string;
-    time?: {
-        created: number;
-        completed?: number;
-    };
-    error?: unknown;
-}
-export interface StoredTextPart {
-    id: string;
-    sessionID: string;
-    messageID: string;
-    type: "text";
-    text: string;
-    synthetic?: boolean;
-    ignored?: boolean;
-}
-export interface StoredToolPart {
-    id: string;
-    sessionID: string;
-    messageID: string;
-    type: "tool";
-    callID: string;
-    tool: string;
-    state: {
-        status: "pending" | "running" | "completed" | "error";
-        input: Record<string, unknown>;
-        output?: string;
-        error?: string;
-    };
-}
-export interface StoredReasoningPart {
-    id: string;
-    sessionID: string;
-    messageID: string;
-    type: "reasoning";
-    text: string;
-}
-export interface StoredStepPart {
-    id: string;
-    sessionID: string;
-    messageID: string;
-    type: "step-start" | "step-finish";
-}
-export type StoredPart = StoredTextPart | StoredToolPart | StoredReasoningPart | StoredStepPart | {
-    id: string;
-    sessionID: string;
-    messageID: string;
-    type: string;
-    [key: string]: unknown;
-};
-export interface MessagePart {
-    type: string;
-    id?: string;
-    text?: string;
-    thinking?: string;
-    name?: string;
-    input?: Record<string, unknown>;
-    callID?: string;
-}
-export interface MessageData {
-    info?: {
-        id?: string;
-        role?: string;
-        sessionID?: string;
-        parentID?: string;
-        error?: unknown;
-        agent?: string;
-        model?: {
-            providerID: string;
-            modelID: string;
-        };
-        system?: string;
-        tools?: Record<string, boolean>;
-    };
-    parts?: MessagePart[];
-}
-export interface MessageInfo {
-    id?: string;
-    role?: string;
-    sessionID?: string;
-    parentID?: string;
-    error?: unknown;
-}
-export interface ResumeConfig {
-    sessionID: string;
-    agent?: string;
-    model?: {
-        providerID: string;
-        modelID: string;
-    };
-}
-export type RecoveryErrorType = "tool_result_missing" | "thinking_block_order" | "thinking_disabled_violation" | null;
-export interface ToolUsePart {
-    type: "tool_use";
-    id: string;
-    name: string;
-    input: Record<string, unknown>;
-}
-export interface ToolResultPart {
-    type: "tool_result";
-    tool_use_id: string;
-    content: string;
-}

package/dist/plugin/recovery/types.js

@@ -1,6 +0,0 @@
-/**
- * Types for session recovery.
- *
- * Based on oh-my-opencode/src/hooks/session-recovery/types.ts
- */
-export {};

package/dist/plugin/recovery.d.ts

@@ -1,60 +0,0 @@
-/**
- * Session recovery hook for handling recoverable errors.
- *
- * Supports:
- * - tool_result_missing: When ESC is pressed during tool execution
- * - thinking_block_order: When thinking blocks are corrupted/stripped
- * - thinking_disabled_violation: Thinking in non-thinking model
- *
- * Based on oh-my-opencode/src/hooks/session-recovery/index.ts
- */
-import type { AntigravityConfig } from "./config";
-import type { PluginClient } from "./types";
-import type { MessageInfo, RecoveryErrorType } from "./recovery/types";
-/**
- * Detect the type of recoverable error from an error object.
- */
-export declare function detectErrorType(error: unknown): RecoveryErrorType;
-/**
- * Check if an error is recoverable.
- */
-export declare function isRecoverableError(error: unknown): boolean;
-export declare function getRecoveryToastContent(errorType: RecoveryErrorType): {
-    title: string;
-    message: string;
-};
-export declare function getRecoverySuccessToast(): {
-    title: string;
-    message: string;
-};
-export declare function getRecoveryFailureToast(): {
-    title: string;
-    message: string;
-};
-export interface SessionRecoveryHook {
-    /**
-     * Main recovery handler. Performs the actual fix.
-     * Returns true if recovery was successful.
-     */
-    handleSessionRecovery: (info: MessageInfo) => Promise<boolean>;
-    /**
-     * Check if the error is recoverable.
-     */
-    isRecoverableError: (error: unknown) => boolean;
-    /**
-     * Callback for when a session is being aborted for recovery.
-     */
-    setOnAbortCallback: (callback: (sessionID: string) => void) => void;
-    /**
-     * Callback for when recovery is complete (success or failure).
-     */
-    setOnRecoveryCompleteCallback: (callback: (sessionID: string) => void) => void;
-}
-export interface SessionRecoveryContext {
-    client: PluginClient;
-    directory: string;
-}
-/**
- * Create a session recovery hook with the given configuration.
- */
-export declare function createSessionRecoveryHook(ctx: SessionRecoveryContext, config: AntigravityConfig): SessionRecoveryHook | null;