@vicinae/api 0.9.1 → 0.9.2

package/dist/api/ai.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AI = void 0;
-const stream_1 = require("stream");
-const crypto_1 = require("crypto");
-const bus_1 = require("./bus");
 var AI;
 (function (AI) {
     /**
@@ -36,42 +33,7 @@ var AI;
      * ```
      */
     function ask(prompt, options) {
-        const handlerId = (0, crypto_1.randomUUID)();
-        const emitter = new stream_1.EventEmitter();
-        const promise = new Promise((resolve, reject) => {
-            let answer = "";
-            bus_1.bus
-                .request("ai.create-completion", {
-                prompt,
-                options,
-                callback: handlerId,
-            })
-                .then(({ data }) => {
-                if (!data.started) {
-                    reject(new Error("Could not create completion"));
-                }
-                const { unsubscribe } = bus_1.bus.subscribe(handlerId, (...args) => {
-                    const data = args[0];
-                    answer += data.token;
-                    emitter.emit("data", data.token);
-                    if (data.done) {
-                        unsubscribe();
-                        resolve(answer);
-                    }
-                });
-                if (options?.signal) {
-                    options.signal.addEventListener("abort", () => {
-                        bus_1.bus.request("ai.abort-completion");
-                        unsubscribe();
-                        resolve(answer);
-                    });
-                }
-            })
-                .catch((err) => reject(err));
-        });
-        return Object.assign(promise, {
-            on: emitter.on.bind(emitter),
-        });
+        throw new Error('not implemented');
     }
     AI.ask = ask;
     /**
@@ -115,7 +77,6 @@ var AI;
         Model["OpenAI_GPT3.5-turbo"] = "openai-gpt-3.5-turbo";
     })(Model = AI.Model || (AI.Model = {}));
     AI.getModels = async () => {
-        const res = await bus_1.bus.request("ai.get-models");
-        return res.data.models;
+        throw new Error('not implemented');
     };
 })(AI || (exports.AI = AI = {}));

package/dist/api/alert.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.confirmAlert = exports.Alert = void 0;
-const node_crypto_1 = require("node:crypto");
 const bus_1 = require("./bus");
 const ui_1 = require("./proto/ui");
 var Alert;
@@ -20,22 +19,7 @@ const styleMap = {
 };
 const confirmAlert = async (options) => {
     return new Promise(async (resolve) => {
-        const handle = (0, node_crypto_1.randomUUID)();
-        let confirmCallback = () => { };
-        let cancelCallback = () => { };
-        const { unsubscribe } = bus_1.bus.subscribe(handle, (...args) => {
-            callback(!!args[0]);
-        });
-        const callback = (value) => {
-            if (value)
-                confirmCallback();
-            else
-                cancelCallback();
-            unsubscribe();
-            resolve(value);
-        };
         const req = ui_1.ConfirmAlertRequest.create({
-            handle,
             title: options.title,
             description: options.message ?? "Are you sure?",
             rememberUserChoice: false,
@@ -48,13 +32,16 @@ const confirmAlert = async (options) => {
                 style: styleMap[options.dismissAction?.style ?? Alert.ActionStyle.Cancel],
             },
         });
-        if (options.primaryAction?.onAction) {
-            confirmCallback = options.primaryAction.onAction;
+        const res = await bus_1.bus.turboRequest("ui.confirmAlert", req);
+        if (!res.ok)
+            return false;
+        if (res.value.confirmed) {
+            options.primaryAction?.onAction?.();
         }
-        if (options.dismissAction?.onAction) {
-            cancelCallback = options.dismissAction.onAction;
+        else {
+            options.dismissAction?.onAction?.();
         }
-        await bus_1.bus.turboRequest("ui.confirmAlert", req);
+        resolve(res.value.confirmed);
     });
 };
 exports.confirmAlert = confirmAlert;

package/dist/api/bus.d.ts

@@ -37,6 +37,7 @@ type Responses = {
 type EndpointMapping = {
     "app.list": "app.list";
     "app.open": "app.open";
+    "app.getDefault": "app.getDefault";
     "ui.render": "ui.render";
     "ui.showToast": "ui.showToast";
     "ui.hideToast": "ui.hideToast";
@@ -48,6 +49,14 @@ type EndpointMapping = {
     "ui.setSearchText": "ui.setSearchText";
     "ui.confirmAlert": "ui.confirmAlert";
     "ui.getSelectedText": "ui.getSelectedText";
+    "wm.ping": "wm.ping";
+    "wm.getActiveWindow": "wm.getActiveWindow";
+    "wm.getActiveWorkspace": "wm.getActiveWorkspace";
+    "wm.getWindows": "wm.getWindows";
+    "wm.getWorkspaces": "wm.getWorkspaces";
+    "wm.setWindowBounds": "wm.setWindowBounds";
+    "fileSearch.search": "fileSearch.search";
+    "ui.popToRoot": "ui.popToRoot";
     "storage.get": "storage.get";
     "storage.set": "storage.set";
     "storage.remove": "storage.remove";
@@ -88,13 +97,7 @@ declare class Bus {
     };
     replaceEventHandler(id: string, handler: EventListenerInfo['callback']): void;
     removeEventHandler(id: string): void;
-    request2(data: extension.RequestData, options?: {
-        timeout?: number;
-    }): Promise<Result<extension.ResponseData, Error>>;
-    request<T = Record<string, any>>(action: string, data?: Record<string, any>, options?: {
-        timeout?: number;
-        rejectOnError?: boolean;
-    }): Promise<Message<T>>;
+    private request2;
 }
 /**
  * IPC bus to communicate with the extension manager.

package/dist/api/bus.js

@@ -181,39 +181,6 @@ class Bus {
             }
         });
     }
-    request(action, data = {}, options = {}) {
-        const id = (0, crypto_1.randomUUID)();
-        const { rejectOnError = true } = options;
-        return new Promise((resolve, reject) => {
-            let timeout;
-            if (options.timeout) {
-                timeout = setTimeout(() => reject(new Error(`request timed out`)), options.timeout);
-            }
-            const resolver = (message) => {
-                clearTimeout(timeout);
-                if (message.error && rejectOnError) {
-                    return reject(message.error.message ?? "Unknown error");
-                }
-                resolve(message);
-            };
-            try {
-                this.requestMap.set(id, { resolve: resolver });
-                const message = {
-                    envelope: {
-                        type: "request",
-                        action,
-                        id,
-                    },
-                    data,
-                    error: null,
-                };
-                this.port.postMessage(message);
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
 }
 /**
  * IPC bus to communicate with the extension manager.

package/dist/api/cache.d.ts

@@ -1,56 +1,46 @@
-interface AbstractCache {
-    /**
-     * @returns the full path to the directory where the data is stored on disk.
-     */
-    get storageDirectory(): string;
-    /**
-     * @returns the data for the given key. If there is no data for the key, `undefined` is returned.
-     * @remarks If you want to just check for the existence of a key, use {@link has}.
-     */
-    get(key: string): string | undefined;
-    /**
-     * @returns `true` if data for the key exists, `false` otherwise.
-     * @remarks You can use this method to check for entries without affecting the LRU access.
-     */
-    has(key: string): boolean;
-    /**
-     * @returns `true` if the cache is empty, `false` otherwise.
-     */
-    get isEmpty(): boolean;
-    /**
-     * Sets the data for the given key.
-     * If the data exceeds the configured `capacity`, the least recently used entries are removed.
-     * This also notifies registered subscribers (see {@link subscribe}).
-     */
-    set(key: string, data: string): void;
-    /**
-     * Removes the data for the given key.
-     * This also notifies registered subscribers (see {@link subscribe}).
-     * @returns `true` if data for the key was removed, `false` otherwise.
-     */
-    remove(key: string): boolean;
-    /**
-     * Clears all stored data.
-     * This also notifies registered subscribers (see {@link subscribe}) unless the  `notifySubscribers` option is set to `false`.
-     */
-    clear(options?: {
-        notifySubscribers: boolean;
-    }): void;
+export declare namespace Cache {
     /**
-     * Registers a new subscriber that gets notified when cache data is set or removed.
-     * @returns a function that can be called to remove the subscriber.
+     * The options for creating a new {@link Cache}.
      */
-    subscribe(subscriber: Cache.Subscriber): Cache.Subscription;
+    interface Options {
+        /**
+         * If set, the Cache will be namespaced via a subdirectory.
+         * This can be useful to separate the caches for individual commands of an extension.
+         * By default, the cache is shared between the commands of an extension.
+         */
+        namespace?: string;
+        /**
+         * The capacity in bytes. If the stored data exceeds the capacity, the least recently used data is removed.
+         * The default capacity is 10 MB.
+         */
+        capacity?: number;
+    }
+    type Subscriber = (key: string | undefined, data: string | undefined) => void;
+    type Subscription = () => void;
 }
-export declare class Cache implements AbstractCache {
+/**
+ * Caching abstraction that stores data on disk and supports LRU (least recently used) access.
+ * Values can only be stored as plain text strings, so it is up to you to serialize your data in an appropriate way.
+ * For instance, you could store json using `JSON.stringify` and `JSON.parse` it back.
+ * If you need to store binary data, you could encode it in base64.
+ *
+ * Unlike the local storage API, this API exclusively uses the extension's support directory to store its data.
+ * No calls to internal Vicinae APIs are required, hence why all methods in this class are synchronous.
+ * Another major difference is that cache data is not encrypted, so it's not suitable to store secrets.
+ * (local storage currently isn't either, but that will change in the future)
+ */
+export declare class Cache {
     constructor(options?: Cache.Options);
     /**
      * @returns the full path to the directory where the data is stored on disk.
+     * @remarks This is provided for informative purpose only. You should not attempt to mutate anything
+     * in this directory by yourself. Also note that the way cache data is serialized on disk can (will) change
+     * across versions.
      */
     get storageDirectory(): string;
     /**
-     * @returns the data for the given key. If there is no data for the key, `undefined` is returned.
-     * @remarks If you want to just check for the existence of a key, use {@link has}.
+     * @returns the data for the given key, or `undefined` if there is no data.
+     * @remarks To solely check for existence of a key, use {@link has}.
      */
     get(key: string): string | undefined;
     /**
@@ -59,13 +49,14 @@ export declare class Cache implements AbstractCache {
      */
     has(key: string): boolean;
     /**
-     * @returns `true` if the cache is empty, `false` otherwise.
+     * @returns whether the cache is empty.
      */
     get isEmpty(): boolean;
     /**
      * Sets the data for the given key.
      * If the data exceeds the configured `capacity`, the least recently used entries are removed.
      * This also notifies registered subscribers (see {@link subscribe}).
+     * @remarks An individual cache entry cannot be bigger than the configured capacity. If this happens, an error will be thrown.
      */
     set(key: string, data: string): void;
     /**
@@ -86,32 +77,32 @@ export declare class Cache implements AbstractCache {
      * @returns a function that can be called to remove the subscriber.
      */
     subscribe(subscriber: Cache.Subscriber): Cache.Subscription;
-    private maintainCapacity;
-    private notifySubscribers;
-}
-export declare namespace Cache {
-    /**
-     * The options for creating a new {@link Cache}.
-     */
-    interface Options {
-        /**
-         * If set, the Cache will be namespaced via a subdirectory.
-         * This can be useful to separate the caches for individual commands of an extension.
-         * By default, the cache is shared between the commands of an extension.
-         */
-        namespace?: string;
-        /**
-         * The parent directory for the cache data.
-         * @deprecated this parameter will be removed in the future – use the default directory.
-         */
-        directory?: string;
-        /**
-         * The capacity in bytes. If the stored data exceeds the capacity, the least recently used data is removed.
-         * The default capacity is 10 MB.
-         */
-        capacity?: number;
-    }
-    type Subscriber = (key: string | undefined, data: string | undefined) => void;
-    type Subscription = () => void;
+    private keyDataPath;
+    private readKeyData;
+    private writeKeyData;
+    private keyHash;
+    private get dataDir();
+    private dataPath;
+    private get indexPath();
+    private updateLRU;
+    private popLRU;
+    private removeImpl;
+    private initIndex;
+    private loadIndex;
+    private removeCacheDirectory;
+    private syncIndex;
+    private emptyIndex;
+    /**
+     * We store this inside the cache index file in order to know
+     * when a breaking change occurs.
+     * If we want to change the way the data is stored we just change this,
+     * which will force a full cache clear and use the new format.
+     */
+    private revision;
+    private capacity;
+    private subscribers;
+    private storageDir;
+    private index;
+    private static DEFAULT_CACHE_SIZE;
+    private static CACHE_DIR_NAME;
 }
-export {};

package/dist/api/cache.js

@@ -1,61 +1,210 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = require("node:fs");
+const node_crypto_1 = require("node:crypto");
+const environment_1 = require("./environment");
+/**
+ * Caching abstraction that stores data on disk and supports LRU (least recently used) access.
+ * Values can only be stored as plain text strings, so it is up to you to serialize your data in an appropriate way.
+ * For instance, you could store json using `JSON.stringify` and `JSON.parse` it back.
+ * If you need to store binary data, you could encode it in base64.
+ *
+ * Unlike the local storage API, this API exclusively uses the extension's support directory to store its data.
+ * No calls to internal Vicinae APIs are required, hence why all methods in this class are synchronous.
+ * Another major difference is that cache data is not encrypted, so it's not suitable to store secrets.
+ * (local storage currently isn't either, but that will change in the future)
+ */
 class Cache {
-    constructor(options) { }
+    constructor(options) {
+        this.storageDir = node_path_1.default.join(environment_1.environment.supportPath, Cache.CACHE_DIR_NAME);
+        this.capacity = options?.capacity ?? Cache.DEFAULT_CACHE_SIZE;
+        if (options?.namespace) {
+            this.storageDir = node_path_1.default.join(this.storageDir, options.namespace);
+        }
+        (0, node_fs_1.mkdirSync)(this.dataDir, { recursive: true });
+        this.index = this.loadIndex() ?? this.emptyIndex();
+        if (this.index.revision !== this.revision) {
+            this.clear();
+        }
+    }
     /**
      * @returns the full path to the directory where the data is stored on disk.
+     * @remarks This is provided for informative purpose only. You should not attempt to mutate anything
+     * in this directory by yourself. Also note that the way cache data is serialized on disk can (will) change
+     * across versions.
      */
     get storageDirectory() {
-        return "";
+        return this.storageDir;
     }
     /**
-     * @returns the data for the given key. If there is no data for the key, `undefined` is returned.
-     * @remarks If you want to just check for the existence of a key, use {@link has}.
+     * @returns the data for the given key, or `undefined` if there is no data.
+     * @remarks To solely check for existence of a key, use {@link has}.
      */
     get(key) {
-        return undefined;
+        const info = this.index.keys[key];
+        if (!info)
+            return undefined;
+        this.updateLRU(key);
+        this.syncIndex();
+        return this.readKeyData(key);
     }
     /**
      * @returns `true` if data for the key exists, `false` otherwise.
      * @remarks You can use this method to check for entries without affecting the LRU access.
      */
     has(key) {
-        return false;
+        return typeof this.index.keys[key] !== 'undefined';
     }
     /**
-     * @returns `true` if the cache is empty, `false` otherwise.
+     * @returns whether the cache is empty.
      */
     get isEmpty() {
-        return true;
+        return Object.keys(this.index.keys).length === 0;
     }
     /**
      * Sets the data for the given key.
      * If the data exceeds the configured `capacity`, the least recently used entries are removed.
      * This also notifies registered subscribers (see {@link subscribe}).
+     * @remarks An individual cache entry cannot be bigger than the configured capacity. If this happens, an error will be thrown.
      */
-    set(key, data) { }
+    set(key, data) {
+        if (data.length > this.capacity) {
+            throw new Error(`A single cache entry cannot be bigger than the total capacity of the cache. The data for key ${key} is ${data.length} bytes long while the capacity is set to ${this.capacity}. You should either reduce the amount of data stored or increase the cache's capacity.`);
+        }
+        const info = this.index.keys[key];
+        let newTotalSize = this.index.size + data.length - (info?.size ?? 0);
+        if (newTotalSize > this.capacity) {
+            this.popLRU();
+            return this.set(key, data); // FIXME: get rid of recursion 
+        }
+        this.index.size = newTotalSize;
+        this.index.keys[key] = { size: data.length };
+        this.updateLRU(key);
+        for (const sub of this.subscribers) {
+            sub(key, data);
+        }
+        this.writeKeyData(key, data);
+        this.syncIndex();
+    }
     /**
      * Removes the data for the given key.
      * This also notifies registered subscribers (see {@link subscribe}).
      * @returns `true` if data for the key was removed, `false` otherwise.
      */
     remove(key) {
-        return false;
+        const removed = this.removeImpl(key);
+        this.syncIndex();
+        return removed;
     }
     /**
      * Clears all stored data.
      * This also notifies registered subscribers (see {@link subscribe}) unless the  `notifySubscribers` option is set to `false`.
      */
-    clear(options) { }
+    clear(options) {
+        const notify = options?.notifySubscribers ?? true;
+        this.removeCacheDirectory();
+        this.initIndex();
+        if (!notify)
+            return;
+        for (const key of Object.keys(this.index.keys)) {
+            for (const subscriber of this.subscribers) {
+                subscriber(key, undefined);
+            }
+        }
+    }
     /**
      * Registers a new subscriber that gets notified when cache data is set or removed.
      * @returns a function that can be called to remove the subscriber.
      */
     subscribe(subscriber) {
-        return () => { };
+        this.subscribers.push(subscriber);
+        return () => {
+            this.subscribers.splice(this.subscribers.indexOf(subscriber), 1);
+        };
+    }
+    keyDataPath(key) {
+        return this.dataPath(this.keyHash(key));
+    }
+    readKeyData(key) {
+        return (0, node_fs_1.readFileSync)(this.keyDataPath(key), 'utf8');
+    }
+    writeKeyData(key, data) {
+        (0, node_fs_1.writeFileSync)(this.keyDataPath(key), data);
+    }
+    keyHash(key) {
+        return (0, node_crypto_1.hash)('md5', key);
+    }
+    get dataDir() {
+        return node_path_1.default.join(this.storageDir, 'data');
+    }
+    dataPath(id) {
+        return node_path_1.default.join(this.dataDir, id);
+    }
+    get indexPath() {
+        return node_path_1.default.join(this.storageDir, 'index.json');
     }
-    maintainCapacity;
-    notifySubscribers;
+    updateLRU(key) {
+        const idx = this.index.lru.findIndex((entry) => key == entry.key);
+        if (idx !== -1)
+            this.index.lru.splice(idx, 1);
+        this.index.lru.unshift({ key, lastUsedAt: Date.now() });
+    }
+    popLRU() {
+        if (this.index.lru.length === 0)
+            return;
+        this.removeImpl(this.index.lru.pop().key);
+    }
+    removeImpl(key) {
+        const info = this.index.keys[key];
+        if (!info)
+            return false;
+        (0, node_fs_1.rmSync)(this.keyDataPath(key), { force: true });
+        this.index.size -= info.size;
+        delete this.index.keys[key];
+        for (const sub of this.subscribers) {
+            sub(key, undefined);
+        }
+        return true;
+    }
+    initIndex() {
+        const index = { revision: this.revision, keys: {}, size: 0, lru: [] };
+        (0, node_fs_1.mkdirSync)(this.dataDir, { recursive: true });
+        const indexPath = node_path_1.default.join(this.storageDir, "index.json");
+        (0, node_fs_1.writeFileSync)(indexPath, JSON.stringify(index, null, 2));
+        return index;
+    }
+    loadIndex() {
+        const indexPath = node_path_1.default.join(this.storageDir, "index.json");
+        if (!(0, node_fs_1.existsSync)(indexPath))
+            return null;
+        return JSON.parse((0, node_fs_1.readFileSync)(indexPath, 'utf8'));
+    }
+    removeCacheDirectory() {
+        (0, node_fs_1.rmSync)(this.dataDir, { recursive: true, force: true });
+    }
+    syncIndex() {
+        (0, node_fs_1.writeFileSync)(this.indexPath, JSON.stringify(this.index, null, 2));
+    }
+    emptyIndex() {
+        return { revision: this.revision, keys: {}, lru: [], size: 0 };
+    }
+    /**
+     * We store this inside the cache index file in order to know
+     * when a breaking change occurs.
+     * If we want to change the way the data is stored we just change this,
+     * which will force a full cache clear and use the new format.
+     */
+    revision = '1';
+    capacity;
+    subscribers = [];
+    storageDir;
+    index;
+    static DEFAULT_CACHE_SIZE = 1e7;
+    static CACHE_DIR_NAME = ".cache";
 }
 exports.Cache = Cache;

package/dist/api/clipboard.d.ts

@@ -30,5 +30,5 @@ export declare const Clipboard: {
     readText(options?: {
         offset?: number;
     }): Promise<string | undefined>;
-    clear(text: string): Promise<void>;
+    clear(text: string): Promise<never>;
 };

package/dist/api/clipboard.js

@@ -34,18 +34,12 @@ exports.Clipboard = {
         });
     },
     async read(options) {
-        const res = await bus_1.bus.request("clipboard.read", {
-            options,
-        });
-        return res.data.content;
+        throw new Error('Clipboard.read not implemented');
     },
     async readText(options) {
-        const res = await bus_1.bus.request("clipboard.read-text", {
-            options,
-        });
-        return res.data.content;
+        throw new Error('Clipboard.readText not implemented');
     },
     async clear(text) {
-        // TODO: implement
+        throw new Error('Clibpoard.clear not implemented');
     },
 };

package/dist/api/controls.d.ts

@@ -1,3 +1,6 @@
 export declare const closeMainWindow: () => Promise<void>;
 export declare const clearSearchBar: () => Promise<void>;
 export declare const getSelectedText: () => Promise<string>;
+export declare const popToRoot: (options?: {
+    clearSearchBar?: boolean;
+}) => Promise<void>;

package/dist/api/controls.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSelectedText = exports.clearSearchBar = exports.closeMainWindow = void 0;
+exports.popToRoot = exports.getSelectedText = exports.clearSearchBar = exports.closeMainWindow = void 0;
 const bus_1 = require("./bus");
 const closeMainWindow = async () => {
     await bus_1.bus.turboRequest("ui.closeMainWindow", {});
@@ -18,3 +18,7 @@ const getSelectedText = async () => {
     return response.value.text;
 };
 exports.getSelectedText = getSelectedText;
+const popToRoot = async (options) => {
+    await bus_1.bus.turboRequest('ui.popToRoot', { clearSearchBar: options?.clearSearchBar ?? false });
+};
+exports.popToRoot = popToRoot;

package/dist/api/environment.d.ts

@@ -121,5 +121,10 @@ export interface Environment {
         tag: string;
         commit: string;
     };
+    /**
+     * Whether we run an actual Raycast extension in compatibility mode.
+     * This is used internally to provide Raycast-compatible interfaces.
+     */
+    isRaycast: boolean;
 }
 export declare const environment: Environment;