@dinoxx/dinox-cli 2.3.0 → 2.5.2

package/dist/gateway/types.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Dinox agent gateway: hosts external agent runtimes (Hermes, OpenClaw, pi,
+ * Claude Code, Codex, ... over ACP) as remote devices the Dinox app can drive.
+ *
+ * The app sees each gateway as one `dinox.remote-device.v2` device. The agent
+ * owns its conversation context (gateway-session mode): each turn sends the new
+ * user message plus any transcript messages its session has not seen (another
+ * agent answered meanwhile), while Dinox keeps the synced copy of the transcript.
+ */
+export type GatewayKind = 'acp' | 'echo';
+/**
+ * When the agent must ask before acting: `ask` every time, or `auto_read`
+ * (reading and searching run without asking; edits and commands still ask).
+ */
+export type GatewayApprovalMode = 'ask' | 'auto_read';
+/** Local-only gateway definition (never synced: it may carry commands and env). */
+export type GatewayDefinition = {
+    /** Stable id; also the `c_robot.id` the app binds agents to. */
+    id: string;
+    name: string;
+    kind: GatewayKind;
+    /** Detected agent type (`cursor`, `opencode`, ...); one gateway per type per machine. */
+    agentId?: string;
+    /** NATS device id the app addresses (`[a-z0-9][a-z0-9_-]{0,63}`). */
+    deviceId: string;
+    /** ACP: executable started over stdio, e.g. `hermes` with args `["acp"]`. */
+    command?: string;
+    args?: string[];
+    /** Working directory for new agent sessions (each session keeps the one it started in). */
+    cwd?: string;
+    /**
+     * Directory of sessions bound before sessions recorded their own: the
+     * default directory as it was when it was first changed.
+     */
+    previousCwd?: string;
+    /** Extra environment for the agent process (secrets stay on this machine). */
+    env?: Record<string, string>;
+    enabled: boolean;
+    /** Offer the read-only Dinox knowledge tools (MCP) to the agent; default true. */
+    dinoxTools?: boolean;
+    /** Default `ask`. */
+    approval?: GatewayApprovalMode;
+    /** Stays online but refuses new turns, so the owner can resume it from the app. */
+    paused?: boolean;
+    createdAt: string;
+};
+export type GatewayToolStatus = 'pending' | 'running' | 'completed' | 'failed';
+/** Normalized agent output, independent of the adapter protocol. */
+export type GatewayEvent = {
+    type: 'text-delta';
+    text: string;
+} | {
+    type: 'reasoning-delta';
+    text: string;
+} | {
+    type: 'tool';
+    toolCallId: string;
+    title?: string;
+    status?: GatewayToolStatus;
+    input?: unknown;
+    output?: unknown;
+} | {
+    type: 'approval-request';
+    approvalId: string;
+    toolCallId: string;
+    toolName: string;
+    input?: unknown;
+} | {
+    type: 'approval-resolved';
+    approvalId: string;
+    approved: boolean;
+} | {
+    type: 'usage';
+    inputTokens?: number | null;
+    outputTokens?: number | null;
+};
+/**
+ * A choice the agent exposes per session (an ACP select config option), e.g.
+ * its model or mode. Values are the agent's own ids; `group` is set when the
+ * agent groups its values (OpenCode groups models by provider).
+ */
+export type GatewayConfigOption = {
+    id: string;
+    name: string;
+    /** ACP semantic category: `model`, `mode`, `thought_level`, ... (UX only). */
+    category: string | null;
+    description: string | null;
+    currentValue: string;
+    values: Array<{
+        value: string;
+        name: string;
+        description: string | null;
+        group: string | null;
+    }>;
+};
+export type GatewayStopReason = 'end_turn' | 'cancelled' | 'max_tokens' | 'refusal' | 'error';
+export type GatewayTurnInput = {
+    /** Agent session to continue; absent starts a new one. */
+    sessionId: string | null;
+    /** Working directory of the session (a new one starts here; a continued one is loaded with it). */
+    cwd: string;
+    prompt: string;
+    /** Prepended to the prompt when the turn starts a new session, e.g. the agent's instructions. */
+    sessionPreamble?: string;
+    /** Attachments the user sent with this turn (trusted, https). */
+    resources: Array<{
+        uri: string;
+        name: string;
+        mediaType?: string | null;
+    }>;
+    signal: AbortSignal;
+    /** Option id → value to apply to the session before the prompt; unknown entries are skipped. */
+    config?: Readonly<Record<string, string>>;
+    onEvent: (event: GatewayEvent) => void;
+    /** Resolves with the user's decision for an `approval-request` event. */
+    awaitApproval: (approvalId: string) => Promise<boolean>;
+};
+export type GatewayTurnResult = {
+    sessionId: string;
+    stopReason: GatewayStopReason;
+    error?: string;
+};
+export type GatewayAdapterInfo = {
+    kind: GatewayKind;
+    agentName: string | null;
+    agentVersion: string | null;
+};
+/** One agent runtime. Implementations keep their own process/connection state. */
+export interface GatewayAdapter {
+    readonly kind: GatewayKind;
+    info(): GatewayAdapterInfo;
+    runTurn(input: GatewayTurnInput): Promise<GatewayTurnResult>;
+    /** The agent's session settings (models, modes); absent when it has none. */
+    describeConfig?(): Promise<GatewayConfigOption[]>;
+    dispose(): Promise<void>;
+}

package/dist/gateway/types.js

@@ -0,0 +1,10 @@
+/**
+ * Dinox agent gateway: hosts external agent runtimes (Hermes, OpenClaw, pi,
+ * Claude Code, Codex, ... over ACP) as remote devices the Dinox app can drive.
+ *
+ * The app sees each gateway as one `dinox.remote-device.v2` device. The agent
+ * owns its conversation context (gateway-session mode): each turn sends the new
+ * user message plus any transcript messages its session has not seen (another
+ * agent answered meanwhile), while Dinox keeps the synced copy of the transcript.
+ */
+export {};

package/dist/gateway/workspaceFolders.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Folders an agent may work in, chosen from the app. The rules keep a remote
+ * choice inside the owner's own files: an existing directory under the home
+ * directory, never the home directory itself, nothing hidden (`~/.ssh`) and
+ * nothing in `~/Library`. Not a security boundary on its own (an agent with a
+ * shell can still `cd`); it keeps a tap from pointing an agent somewhere wrong.
+ */
+export type WorkspaceFolderErrorCode = 'not_found' | 'not_allowed';
+export declare class WorkspaceFolderError extends Error {
+    readonly code: WorkspaceFolderErrorCode;
+    constructor(code: WorkspaceFolderErrorCode, message: string);
+}
+export type WorkspaceFolder = {
+    name: string;
+    path: string;
+    /** Has a `.git` entry: likely a project the user works on. */
+    isProject: boolean;
+};
+/** The folder an agent may work in, resolved to its real path. */
+export declare function resolveWorkspaceFolder(input: string, home?: string): Promise<string>;
+/** `~/Dinox Agents/<agent name>`: a folder of the agent's own, offered as the default choice. */
+export declare function agentHomeFolder(agentName: string, home?: string): string;
+/** Creates the agent's own folder when missing; the only folder the app can create. */
+export declare function ensureAgentHomeFolder(agentName: string, home?: string): Promise<string>;
+/** The visible subfolders of a folder (the home folder included), for browsing. */
+export declare function listWorkspaceFolders(input: string | null | undefined, home?: string): Promise<{
+    path: string;
+    parent: string | null;
+    folders: WorkspaceFolder[];
+    truncated: boolean;
+}>;
+/** Folders worth offering first: the given candidates that exist and are allowed, deduplicated. */
+export declare function existingWorkspaceFolders(candidates: Array<string | null | undefined>, home?: string): Promise<WorkspaceFolder[]>;

package/dist/gateway/workspaceFolders.js

@@ -0,0 +1,129 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+export class WorkspaceFolderError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'WorkspaceFolderError';
+    }
+}
+const MAX_FOLDERS = 200;
+/** Home-level folders that hold system data rather than the user's work. */
+const SYSTEM_FOLDERS = new Set(['Library', 'Applications']);
+const SKIPPED_FOLDERS = new Set(['node_modules']);
+const AGENT_HOME_PARENT = 'Dinox Agents';
+async function realHome(home) {
+    return fs.realpath(home).catch(() => path.resolve(home));
+}
+function expandHome(input, home) {
+    if (input === '~')
+        return home;
+    if (input.startsWith('~/'))
+        return path.join(home, input.slice(2));
+    return input;
+}
+/** Segments of `target` below `home`, or null when it is not inside it. */
+function segmentsBelow(home, target) {
+    const relative = path.relative(home, target);
+    if (relative === '')
+        return [];
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        return null;
+    return relative.split(path.sep);
+}
+function isAllowedBelowHome(segments) {
+    if (segments.some((segment) => segment.startsWith('.')))
+        return false;
+    return !SYSTEM_FOLDERS.has(segments[0] ?? '');
+}
+async function resolveDirectory(input, home) {
+    const expanded = expandHome(input.trim(), home);
+    if (!path.isAbsolute(expanded)) {
+        throw new WorkspaceFolderError('not_allowed', 'Folder must be an absolute path');
+    }
+    // Refused by its name whether or not it exists (`~/.ssh`), so the answer
+    // never depends on what this computer happens to have.
+    const named = segmentsBelow(path.resolve(home), path.resolve(expanded));
+    if (named !== null && !isAllowedBelowHome(named)) {
+        throw new WorkspaceFolderError('not_allowed', 'This folder cannot be used');
+    }
+    let real;
+    try {
+        real = await fs.realpath(expanded);
+    }
+    catch {
+        throw new WorkspaceFolderError('not_found', 'Folder does not exist');
+    }
+    const stat = await fs.stat(real);
+    if (!stat.isDirectory())
+        throw new WorkspaceFolderError('not_found', 'Not a folder');
+    const segments = segmentsBelow(await realHome(home), real);
+    if (segments === null || !isAllowedBelowHome(segments)) {
+        throw new WorkspaceFolderError('not_allowed', 'This folder cannot be used');
+    }
+    return { real, segments };
+}
+/** The folder an agent may work in, resolved to its real path. */
+export async function resolveWorkspaceFolder(input, home = os.homedir()) {
+    const { real, segments } = await resolveDirectory(input, home);
+    if (segments.length === 0) {
+        throw new WorkspaceFolderError('not_allowed', 'Choose a folder inside your home folder');
+    }
+    return real;
+}
+/** `~/Dinox Agents/<agent name>`: a folder of the agent's own, offered as the default choice. */
+export function agentHomeFolder(agentName, home = os.homedir()) {
+    const safeName = agentName.replace(/[\u0000-\u001f\u007f/\\:*?"<>|]/g, '').trim() || 'Agent';
+    return path.join(home, AGENT_HOME_PARENT, safeName.slice(0, 64));
+}
+/** Creates the agent's own folder when missing; the only folder the app can create. */
+export async function ensureAgentHomeFolder(agentName, home = os.homedir()) {
+    const folder = agentHomeFolder(agentName, home);
+    await fs.mkdir(folder, { recursive: true, mode: 0o755 });
+    return resolveWorkspaceFolder(folder, home);
+}
+async function hasGit(folder) {
+    return fs
+        .access(path.join(folder, '.git'))
+        .then(() => true)
+        .catch(() => false);
+}
+/** The visible subfolders of a folder (the home folder included), for browsing. */
+export async function listWorkspaceFolders(input, home = os.homedir()) {
+    const { real, segments } = await resolveDirectory(input?.trim() || home, home);
+    const entries = await fs.readdir(real, { withFileTypes: true });
+    const names = entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .filter((name) => !name.startsWith('.') && !SKIPPED_FOLDERS.has(name))
+        .filter((name) => segments.length > 0 || !SYSTEM_FOLDERS.has(name))
+        .sort((a, b) => a.localeCompare(b));
+    const shown = names.slice(0, MAX_FOLDERS);
+    const folders = await Promise.all(shown.map(async (name) => {
+        const folder = path.join(real, name);
+        return { name, path: folder, isProject: await hasGit(folder) };
+    }));
+    return {
+        path: real,
+        parent: segments.length === 0 ? null : path.dirname(real),
+        folders,
+        truncated: names.length > shown.length,
+    };
+}
+/** Folders worth offering first: the given candidates that exist and are allowed, deduplicated. */
+export async function existingWorkspaceFolders(candidates, home = os.homedir()) {
+    const seen = new Set();
+    const folders = [];
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        const folder = await resolveWorkspaceFolder(candidate, home).catch(() => null);
+        if (!folder || seen.has(folder))
+            continue;
+        seen.add(folder);
+        folders.push({ name: path.basename(folder), path: folder, isProject: await hasGit(folder) });
+    }
+    return folders;
+}

package/dist/vendor/electron/domain/properties.js

@@ -3,7 +3,7 @@
  * Inputs: typed PowerSync read-model and command payloads for property definitions and note values.
  * Outputs: catalog rows plus transactional definition, migration, and note-property mutations.
  */
-import { ACTIVE_PROPERTY_TYPES, applyNotePropertySlotOperation, buildPropertyDefConfigKey, coercePropertyValue, DEFAULT_STATUS_OPTION_INPUTS, findPropertyOptionById, findPropertyOptionByLabel, getDefaultPropertyDefConfig, isIssuedUniqueId, isPropertyKeyValid, isPropertyType, mergeNotePropertiesPatch, NOTE_PROPERTY_LIMITS, normalizeDatePropertyValue, normalizeFilePropertyValue, normalizeNumberPropertyValue, normalizePlacePropertyValue, normalizePropertyDefConfig, normalizePropertyOptionLabel, normalizePropertyOptions, normalizeUniqueIdPrefix, normalizeUrlPropertyValue, parsePropertyDefConfigEnvelope, parsePropertyDefOptionsEnvelope, parseStoredNoteProperties, parseUniqueIdPropertyConfig, propertyOptionLabelKey, PROPERTY_DEF_CONFIG_KEY_PREFIX, PROPERTY_OPTION_COLORS, PROPERTY_OPTION_LABEL_MAX_LENGTH, PROPERTY_OPTION_LIMITS, savedViewFilterSchema, serializePropertyDefConfig, serializePropertyDefOptions, serializeRawNoteProperties, serializeUniqueIdPropertyConfig, STATUS_PROPERTY_GROUPS, tryParseRawNoteProperties, } from "../shared/index.js";
+import { ACTIVE_PROPERTY_TYPES, applyNotePropertySlotOperation, buildPropertyDefConfigKey, coercePropertyValue, DEFAULT_STATUS_OPTION_INPUTS, findPropertyOptionById, findPropertyOptionByLabel, getDefaultPropertyDefConfig, isIssuedUniqueId, isNumberPropertyValueAllowed, isPropertyKeyValid, isPropertyType, mergeNotePropertiesPatch, NOTE_PROPERTY_LIMITS, NUMBER_PROPERTY_PRESETS, normalizeDatePropertyValue, normalizeFilePropertyValue, normalizeNumberPropertyValue, normalizePlacePropertyValue, normalizePropertyDefConfig, normalizePropertyOptionLabel, normalizePropertyOptions, normalizeUniqueIdPrefix, normalizeUrlPropertyValue, parseNumberPropertyPreset, parsePropertyDefConfigEnvelope, parsePropertyDefOptionsEnvelope, parseStoredNoteProperties, parseUniqueIdPropertyConfig, propertyOptionLabelKey, PROPERTY_DEF_CONFIG_KEY_PREFIX, PROPERTY_OPTION_COLORS, PROPERTY_OPTION_LABEL_MAX_LENGTH, PROPERTY_OPTION_LIMITS, savedViewFilterSchema, serializeNumberPropertyPreset, serializePropertyDefConfig, serializePropertyDefOptions, serializeRawNoteProperties, serializeUniqueIdPropertyConfig, STATUS_PROPERTY_GROUPS, tryParseRawNoteProperties, } from "../shared/index.js";
 import { uuidv7 } from "uuidv7";
 import { z } from "zod";
 import { defineCommand, defineReadModel, } from "../rpc.js";
@@ -78,6 +78,7 @@ const PROPERTY_DEF_ENSURE_INPUT = z.object({
     type: z.enum(ACTIVE_PROPERTY_TYPES).nullable().optional(),
     optionItems: z.array(PROPERTY_OPTION_INPUT_SCHEMA).max(PROPERTY_OPTION_LIMITS.items).optional(),
     uniqueIdPrefix: z.string().max(64).nullable().optional(),
+    numberPreset: z.enum(NUMBER_PROPERTY_PRESETS).nullable().optional(),
     config: PROPERTY_DEF_CONFIG_INPUT_SCHEMA.optional(),
     description: z.string().max(2000).nullable().optional(),
     icon: z.string().max(120).nullable().optional(),
@@ -487,6 +488,11 @@ function normalizeExplicitConfig(config, type) {
     return normalized;
 }
 function optionsJsonForNewDefinition(type, input) {
+    if (type === "number") {
+        return input.numberPreset && input.numberPreset !== "number"
+            ? serializeNumberPropertyPreset(input.numberPreset)
+            : null;
+    }
     if (type === "unique_id") {
         return serializeUniqueIdPropertyConfig({
             prefix: normalizeUniqueIdPrefix(input.uniqueIdPrefix, normalizeOptionalString(input.name)),
@@ -1224,6 +1230,11 @@ function normalizeKnownPropertyValue(state, value, allowedArchivedIds) {
             const normalized = normalizeNumberPropertyValue(value, state.config);
             if (normalized === null)
                 throw new Error("PROPERTY_NUMBER_INVALID");
+            // Presets set by dinox-app (rating 0–5 integers, progress 0–1) bind here too.
+            const preset = parseNumberPropertyPreset(state.row.options);
+            if (!isNumberPropertyValueAllowed(normalized, preset)) {
+                throw new Error("PROPERTY_NUMBER_INVALID");
+            }
             return normalized;
         }
         case "date": {

package/dist/vendor/electron/domain/saved-views.js

@@ -862,10 +862,13 @@ function assertConditionSemantics(condition, semantic) {
         normalizeDatePropertyValue(value, semantic.dateMode ?? "date") === null) {
         throw new Error("SAVED_VIEW_INVALID_DATE_VALUE");
     }
+    // Only property-backed selects carry an option list. System list fields such as
+    // `sys.tags` match free values (tag paths), so they must not be checked here.
     if ((semantic.propertyType === "select" ||
         semantic.propertyType === "multi_select") &&
+        semantic.options !== undefined &&
         typeof value === "string" &&
-        !(semantic.options ?? []).some((option) => option.id === value)) {
+        !semantic.options.some((option) => option.id === value)) {
         throw new Error("SAVED_VIEW_OPTION_NOT_FOUND");
     }
 }

package/dist/vendor/electron/shared/external-types.d.ts

@@ -1,2 +1,20 @@
 export type ChatMessageAnchorFields = Record<string, unknown>;
 export type SystemAgentKey = string;
+export type ChatUIMessage = {
+    id: string;
+    role: 'system' | 'user' | 'assistant';
+    parts: Array<Record<string, unknown>>;
+    metadata?: Record<string, unknown>;
+};
+export interface ThreadRunCreateThreadRequest {
+    id: string;
+    name: string;
+    kind?: string | null;
+    userId?: string | null;
+    projectId?: string | null;
+    cmdId?: string | null;
+    metaData?: Record<string, unknown> | null;
+    config?: Record<string, unknown> | null;
+}
+export type ThreadRunEventStatus = 'queued' | 'running' | 'waiting_approval' | 'finalizing' | 'succeeded' | 'failed' | 'cancelled' | 'interrupted' | 'expired';
+export type ThreadRunUsageSnapshot = Record<string, unknown>;

package/dist/vendor/electron/shared/note-properties.d.ts

@@ -155,6 +155,20 @@ export type UrlPropertyDefConfig = {
     type: 'url';
     schemes?: Array<'http' | 'https'>;
 };
+/**
+ * Display/input preset for `number` properties, shared with dinox-app. Stored in
+ * the definition's `options` column as `{ version: 1, number: { preset } }`
+ * (number defs have no select options, so the envelopes never collide).
+ * - progress: stored 0–1, shown as a percentage bar
+ * - rating: integer 0–5, shown as stars
+ */
+export declare const NUMBER_PROPERTY_PRESETS: readonly ["number", "progress", "rating"];
+export type NumberPropertyPreset = (typeof NUMBER_PROPERTY_PRESETS)[number];
+export declare const RATING_PROPERTY_MAX = 5;
+export declare function parseNumberPropertyPreset(raw: string | null | undefined): NumberPropertyPreset | undefined;
+export declare function serializeNumberPropertyPreset(preset: NumberPropertyPreset): string;
+/** Range rules every client enforces for a preset (mirrors dinox-app). */
+export declare function isNumberPropertyValueAllowed(value: unknown, preset?: NumberPropertyPreset): value is number;
 export type PropertyDefConfig = DatePropertyDefConfig | NumberPropertyDefConfig | SelectPropertyDefConfig | MultiSelectPropertyDefConfig | UrlPropertyDefConfig;
 export declare function isPropertyDefSource(value: unknown): value is PropertyDefSource;
 /** Domain form of a synced property-definition catalog entry (camelCase). */
@@ -169,6 +183,8 @@ export interface PropertyDef {
     options?: PropertyOption[];
     /** Counter stored in `c_property_def.options` for `unique_id` (not the select envelope). */
     uniqueId?: UniqueIdPropertyConfig;
+    /** `number` only: progress / rating presentation (absent = plain number). */
+    numberPreset?: NumberPropertyPreset;
     /** Effective type configuration, including legacy defaults when no companion row exists. */
     config?: PropertyDefConfig;
     /** Explicit companion config exists but is malformed, unsupported, or type-mismatched. */

package/dist/vendor/electron/shared/note-properties.js

@@ -64,6 +64,47 @@ export function buildPropertyDefConfigKey(definitionId) {
         throw new Error('INVALID_PROPERTY_DEF_ID');
     return `${PROPERTY_DEF_CONFIG_KEY_PREFIX}${id}`;
 }
+/**
+ * Display/input preset for `number` properties, shared with dinox-app. Stored in
+ * the definition's `options` column as `{ version: 1, number: { preset } }`
+ * (number defs have no select options, so the envelopes never collide).
+ * - progress: stored 0–1, shown as a percentage bar
+ * - rating: integer 0–5, shown as stars
+ */
+export const NUMBER_PROPERTY_PRESETS = ['number', 'progress', 'rating'];
+export const RATING_PROPERTY_MAX = 5;
+export function parseNumberPropertyPreset(raw) {
+    if (!raw || !raw.trim())
+        return undefined;
+    try {
+        const config = JSON.parse(raw);
+        if (!isRecord(config) || config.version !== 1 || !isRecord(config.number))
+            return undefined;
+        const preset = config.number.preset;
+        return NUMBER_PROPERTY_PRESETS.includes(preset)
+            ? preset
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function serializeNumberPropertyPreset(preset) {
+    if (!NUMBER_PROPERTY_PRESETS.includes(preset))
+        throw new Error('INVALID_NUMBER_PROPERTY_PRESET');
+    return JSON.stringify({ version: 1, number: { preset } });
+}
+/** Range rules every client enforces for a preset (mirrors dinox-app). */
+export function isNumberPropertyValueAllowed(value, preset) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return false;
+    if (preset === 'progress')
+        return value >= 0 && value <= 1;
+    if (preset === 'rating') {
+        return Number.isInteger(value) && value >= 0 && value <= RATING_PROPERTY_MAX;
+    }
+    return true;
+}
 export function isPropertyDefSource(value) {
     return value === 'manual' || value === 'ai';
 }
@@ -936,6 +977,9 @@ export function serializePropertyDefConfig(config) {
         throw new Error('INVALID_PROPERTY_DEF_CONFIG');
     return JSON.stringify(normalized);
 }
+function numberPresetField(preset) {
+    return preset && preset !== 'number' ? { numberPreset: preset } : {};
+}
 /** Map a raw c_property_def row into the domain object (unknown type -> text). */
 export function mapPropertyDef(record) {
     const rawType = record.type ?? 'text';
@@ -960,6 +1004,7 @@ export function mapPropertyDef(record) {
                 },
             }
             : {}),
+        ...(type === 'number' ? numberPresetField(parseNumberPropertyPreset(record.options)) : {}),
         config: parsedConfig.status === 'empty'
             ? getDefaultPropertyDefConfig(type, 'legacy')
             : explicitConfigMatches

package/dist/vendor/electron/shared/powersync-read-models.d.ts

@@ -1,5 +1,5 @@
 import type { ChatMessageAnchorFields } from './external-types.js';
-import type { ActivePropertyType, NoteProperties, NotePropertiesPatch, NotePropertySlotOperation, PropertyDefConfig, PropertyDefSource, PropertyOptionInput } from './note-properties.js';
+import type { ActivePropertyType, NoteProperties, NotePropertiesPatch, NotePropertySlotOperation, NumberPropertyPreset, PropertyDefConfig, PropertyDefSource, PropertyOptionInput } from './note-properties.js';
 import type { SystemAgentKey } from './external-types.js';
 export interface ResourceUserListInput {
     userId: string;
@@ -284,6 +284,10 @@ export interface NoteSoftDeleteInput {
     noteId: string;
     updatedAt: string;
 }
+export interface NotePermanentDeleteInput {
+    /** Only notes already in the trash (`is_del = 1`) are removed; others are skipped. */
+    noteIds: string[];
+}
 export interface NoteCommentsReplaceInput {
     noteId: string;
     comments: string;
@@ -1141,6 +1145,8 @@ export interface PropertyDefEnsureInput {
     optionItems?: PropertyOptionInput[];
     /** Prefix for a new `unique_id` counter. Empty falls back to the property name. */
     uniqueIdPrefix?: string | null;
+    /** New `number` definitions only: progress / rating presentation. */
+    numberPreset?: NumberPropertyPreset | null;
     config?: PropertyDefConfig;
     description?: string | null;
     icon?: string | null;