ac-storage 0.16.2 → 0.16.4

package/afron/packages/types/types/rt-var/rt-var-stored.ts

@@ -0,0 +1,30 @@
+/**
+ * backend에서 저장되는 형식
+ */
+export type RTVarStored = (
+    RTVarStoredExternal
+    | RTVarStoredConstant
+    | RTVarStoredForm
+    | RTVarStoredUnknown
+);
+
+export type BaseRTVarStored = {
+    id: string;
+    name: string;
+}
+
+interface RTVarStoredExternal extends BaseRTVarStored {
+    include_type: 'external';
+    external_id: string;
+}
+interface RTVarStoredConstant extends BaseRTVarStored {
+    include_type: 'constant';
+    value: any;
+}
+type RTVarStoredForm = BaseRTVarStored & {
+    include_type: 'form';
+    form_id: string;
+}
+type RTVarStoredUnknown = BaseRTVarStored & {
+    include_type: 'unknown';
+}

package/afron/packages/types/types/rt-var/rt-var-update.ts

@@ -0,0 +1,45 @@
+import { RTVarData } from './var-data';
+
+/**
+ * RTVar 갱신 타입 정의
+ * 
+ * id 필드의 유무에 따라 갱신 구분
+ */
+export type RTVarUpdate = (
+    RTVarIncludePreserveUpdate
+    | RTVarExternalUpdate
+    | RTVarConstantUpdate
+    | RTVarFormUpdate
+);
+
+export type BaseRTVarUpdate = {
+    id: string;
+    name?: string;
+}
+
+export interface RTVarExternalUpdate extends BaseRTVarUpdate {
+    include_type: 'external';
+    external_id: string;
+}
+export interface RTVarConstantUpdate extends BaseRTVarUpdate {
+    include_type: 'constant';
+    value: any;
+}
+export type RTVarFormUpdate = BaseRTVarUpdate & {
+    include_type: 'form';
+} & (
+        {
+            // form_id가 없는 경우 새로운 form 생성
+            form_id?: undefined | null;
+            form_name?: string;
+            data: RTVarData;
+        } | {
+            // form_id가 있으면 기존 form 갱신
+            form_id: string;
+            form_name?: string;
+            data?: RTVarData;
+        }
+    )
+type RTVarIncludePreserveUpdate = BaseRTVarUpdate & {
+    include_type?: undefined;
+}

package/afron/packages/types/types/rt-var/rt-var.ts

@@ -0,0 +1,36 @@
+import { RTVarData } from './var-data';
+
+/**
+ * backend -> frontend 넘겨주는 RTVar 타입 정의
+ */
+export type RTVar = (
+    RTVarExternal
+    | RTVarConstant
+    | RTVarForm
+    | RTVarUnknown
+);
+
+export type BaseRTVar = {
+    id: string;
+    name: string;
+}
+
+export interface RTVarExternal extends BaseRTVar {
+    include_type: 'external';
+    external_id: string;
+}
+export interface RTVarConstant extends BaseRTVar {
+    include_type: 'constant';
+    value: any;
+}
+export type RTVarForm = BaseRTVar & {
+    include_type: 'form';
+    form_id: string;
+    form_name: string;
+    // form_id가 가지고 있는 RTVarData 참조를 함께 리턴
+    data: RTVarData;
+}
+// 외부 소스가 사라진 경우 unknown으로 처리
+export type RTVarUnknown = BaseRTVar & {
+    include_type: 'unknown';
+}

package/afron/packages/types/types/rt-var/var-data.d.ts

@@ -0,0 +1,108 @@
+export type RTVarDataNaive = {
+    type: 'text' | 'number' | 'checkbox' | 'select' | 'array' | 'struct';
+
+    config: {
+        text?: RTVarConfig.Text;
+        number?: RTVarConfig.Number;
+        checkbox?: RTVarConfig.Checkbox;
+        select?: RTVarConfig.Select;
+        array?: RTVarConfig.Array;
+        struct?: RTVarConfig.Struct;
+    }
+}
+
+export type RTVarDataType = RTVarData['type'];
+
+/**
+ * RT 변수 데이터 타입 및 제한 정의
+ * 
+ * RTForm 및 PromptVar에서 사용
+ */
+export type RTVarData = {
+    type: 'text';
+    config: {
+        text: RTVarConfig.Text;
+    }
+} | {
+    type: 'number';
+
+    config: {
+        number: RTVarConfig.Number;
+    }
+} | {
+    type: 'checkbox';
+
+    config: {
+        checkbox: RTVarConfig.Checkbox;
+    }
+} | {
+    type: 'select';
+
+    config: {
+        select: RTVarConfig.Select;
+    }
+} | {
+    type: 'array';
+
+    config: {
+        array: RTVarConfig.Array;
+    }
+} | {
+    type: 'struct';
+
+    config: {
+        struct: RTVarConfig.Struct;
+    }
+};
+
+export namespace RTVarConfig {
+    type Text = {
+        default_value?: string;
+        placeholder: string;
+        allow_multiline: boolean;
+    }
+    type Number = {
+        default_value?: number;
+        minimum_value?: number;
+        maximum_value?: number;
+        allow_decimal: boolean;
+    }
+    type Checkbox = {
+        default_value: boolean;
+    }
+    type Select = {
+        default_value?: string;
+        options: {
+            name: string;
+            value: string;
+        }[];
+    }
+    type Struct = {
+        fields: StructField[];
+    }
+    type StructField = {
+        type: 'text' | 'number' | 'checkbox' | 'select';
+        name: string;
+        display_name: string;
+        config: {
+            text?: Text;
+            number?: Number;
+            checkbox?: Checkbox;
+            select?: Select;
+        }
+    }
+    type Array = {
+        minimum_length?: number;
+        maximum_length?: number;
+        element_type: 'text' | 'number' | 'checkbox' | 'select' | 'struct';
+        config: {
+            text?: Text;
+            number?: Number;
+            checkbox?: Checkbox;
+            select?: Select;
+            struct?: Struct;
+        };
+    }
+}
+
+export { }

package/afron/packages/types/types/storage-schema/ProfileStorageSchema.d.ts

@@ -0,0 +1,2 @@
+export { Session } from './Session';
+export { RT } from './RT';

package/afron/packages/types/types/storage-schema/RT/Flow.d.ts

@@ -0,0 +1,20 @@
+import { FlowNodeType } from '../../rt';
+
+export type Flow = {
+    FlowNode: FlowNode;
+}
+
+export type FlowNode = {
+    type: FlowNodeType;
+    description: string;
+    data: Record<string, any>;
+    connection: Array<{
+        from_handle: string;
+        to_node: string;
+        to_handle: string;
+    }>;
+    position: {
+        x: number;
+        y: number;
+    };
+}

package/afron/packages/types/types/storage-schema/RT/Metadata.d.ts

@@ -0,0 +1,16 @@
+export type Metadata = {
+    version: string;
+    id: string;
+    name: string;
+    uuid: string;
+    mode: 'flow' | 'prompt_only';
+    input_type: 'normal' | 'chat';
+    forms: string[];
+    entrypoint_node: number;
+    prompts: PromptOrder;
+}
+
+type PromptOrder = {
+    id: string;
+    name: string;
+}[];

package/afron/packages/types/types/storage-schema/RT/Prompts.d.ts

@@ -0,0 +1,39 @@
+import { GeminiSafetySetting } from '../../chatai';
+
+export type Prompts = {
+    id: string;
+    name: string
+    variables: PromptVar[];
+    constants: Array<{
+        name: string;
+        value: any;
+    }>;
+    model: {
+        stream: boolean;
+
+        top_p: number;
+        temperature: number;
+        max_tokens: number;
+        use_thinking: boolean;
+        thinking_tokens: number;
+        thinking_auto_budget: boolean;
+        thinking_effort: 'minimal' | 'low' | 'medium' | 'high';
+        verbosity: 'low' | 'medium' | 'high';
+
+        safety_settings: Record<GeminiSafetySetting.FilterNames, GeminiSafetySetting.Threshold>;
+    };
+    contents: string;
+}
+
+type PromptVar = {
+    /** 변수 유형, external/form 선택 시 외부 연결이 끊기면 unknown으로 지정됨 */
+    type: 'constant' | 'form' | 'external' | 'unknown';
+    id: string;
+    name: string;
+    weak?: boolean;
+
+    /** 'form'이면서 form_id가 없다면 id를 form_id로 대체 사용 (이전버전 호환성) */
+    form_id?: string;
+    external_id?: string;
+    value?: any;
+}

package/afron/packages/types/types/storage-schema/RT/RT.d.ts

@@ -0,0 +1,4 @@
+export { RTFormNaive as Form } from '../../rt';
+export { Prompts } from './Prompts';
+export { Metadata } from './Metadata';
+export { Flow } from './Flow';

package/afron/packages/types/types/storage-schema/RT/index.d.ts

@@ -0,0 +1 @@
+export * as RT from './RT';

package/afron/packages/types/types/storage-schema/Session/Cache.d.ts

@@ -0,0 +1,18 @@
+export interface Cache {
+    input: string;
+    output: string;
+    input_token_count: number;
+    last_history: unknown | null;
+    state: string;
+    markdown: boolean;
+    upload_files: SessionUploadFile[] | null;
+}
+
+interface SessionUploadFile {
+    filename: string;
+    data: string;
+    size: number;
+    type: 'image/webp' | 'image/png' | 'image/jpeg' | 'application/pdf' | 'text/plain' | string;
+    thumbnail: string | null;
+    hash_sha256: string;
+}

package/afron/packages/types/types/storage-schema/Session/Config.d.ts

@@ -0,0 +1,7 @@
+export interface Config {
+    name: string;
+    color: string;
+    model_id: string;
+    rt_id: string;
+    delete_lock: boolean;
+}

package/afron/packages/types/types/storage-schema/Session/Data.d.ts

@@ -0,0 +1,19 @@
+
+export interface Data {
+    forms: Record<string, Record<string, unknown>>;
+    custom_models: SessionCustomModel[];
+    running_rt: Record<string, SessionRunningRTEntry>;
+}
+
+interface SessionCustomModel {
+    name: string;
+    url: string;
+    api_format: 'chat_completions' | 'anthropic_claude' | 'generative_language';
+    secret_key: string | null;
+}
+
+interface SessionRunningRTEntry {
+    token: string;
+    created_at: number;
+    state: string;
+}

package/afron/packages/types/types/storage-schema/Session/Session.d.ts

@@ -0,0 +1,3 @@
+export { Cache } from './Cache';
+export { Config } from './Config';
+export { Data } from './Data';

package/afron/packages/types/types/storage-schema/Session/index.d.ts

@@ -0,0 +1 @@
+export * as Session from './Session';

package/afron/packages/types/types/storage-schema/index.d.ts

@@ -0,0 +1,116 @@
+import { GeminiSafetySetting, SupportedThinkingEfforts, SupportedVerbosity } from '../chatai';
+import { FlowNodeType, RTFormNaive } from '../rt';
+
+export * as ProfileStorageSchema from './ProfileStorageSchema';
+
+export declare namespace ProfileStorage {
+    namespace RT {
+        type Index = {
+            version: string;
+            id: string;
+            name: string;
+            uuid: string;
+            mode: 'flow' | 'prompt_only';
+            input_type: 'normal' | 'chat';
+            forms: string[];
+            entrypoint_node: number;
+            prompts: PromptOrder;
+        }
+
+        // form.json 내 { [string]: Form } 형식의 Form에 해당
+        type Form = RTFormNaive;
+
+        // request-template.<rt-id>.prompt.<prompt-id>
+        type Prompt = {
+            id: string;
+            name: string
+            variables: PromptVar[];
+            constants: Array<{
+                name: string;
+                value: any;
+            }>;
+            model: {
+                stream: boolean;
+
+                top_p: number;
+                temperature: number;
+                max_tokens: number;
+                use_thinking: boolean;
+                thinking_tokens: number;
+                thinking_auto_budget: boolean;
+                thinking_effort: 'minimal' | 'low' | 'medium' | 'high';
+                verbosity: 'low' | 'medium' | 'high';
+
+                safety_settings: Record<GeminiSafetySetting.FilterNames, GeminiSafetySetting.Threshold>;
+            };
+            contents: string;
+        }
+
+        type PromptVar = {
+            /** 변수 유형, external/form 선택 시 외부 연결이 끊기면 unknown으로 지정됨 */
+            type: 'constant' | 'form' | 'external' | 'unknown';
+            id: string;
+            name: string;
+            weak?: boolean;
+
+            /** 'form'이면서 form_id가 없다면 id를 form_id로 대체 사용 (이전버전 호환성) */
+            form_id?: string;
+            external_id?: string;
+            value?: any;
+        }
+
+        type FlowNode = {
+            type: FlowNodeType;
+            description: string;
+            data: Record<string, any>;
+            connection: Array<{
+                from_handle: string;
+                to_node: string;
+                to_handle: string;
+            }>;
+            position: {
+                x: number;
+                y: number;
+            };
+        }
+
+        type PromptOrder = {
+            id: string;
+            name: string;
+        }[];
+    }
+}
+
+export type ModelConfiguration = {
+    stream?: boolean;
+
+    temperature?: number;
+    top_p?: number;
+    max_tokens?: number;
+
+    use_thinking?: boolean;
+    thinking_auto_budget?: boolean;
+    thinking_tokens?: number;
+    thinking_effort?: SupportedThinkingEfforts;
+    thinking_summary?: boolean;
+    verbosity?: SupportedVerbosity;
+
+    safety_settings?: Partial<Record<GeminiSafetySetting.FilterNames, GeminiSafetySetting.Threshold>>;
+}
+
+export type GlobalModelConfiguration = {
+    /**
+     * 전역 설정에서 기존 설정을 덮어쓰는지 여부
+     * 
+     * 전역 설정이 아니라면 무시됨
+     */
+    override_enabled?: boolean;
+
+    override_common?: boolean;
+    override_thinking?: boolean;
+    override_safety_settings?: boolean;
+    override_gpt5?: boolean;
+} & ModelConfiguration;
+
+
+export { };

package/afron/packages/types/types/utils/index.ts

@@ -0,0 +1 @@
+export type Optional<T> = T | undefined | null;

package/afron/packages/types/types.d.ts

@@ -0,0 +1,3 @@
+import './types/ipc/interface'
+
+export {};

package/afron/scripts/remove-dist.ps1

@@ -0,0 +1,10 @@
+if ((Split-Path -Leaf (Get-Location)) -eq "scripts") {
+    cd ..
+}
+
+Get-ChildItem -Path ".\packages" -Recurse -Directory -Filter "dist" | Remove-Item -Recurse -Force
+
+
+if (Test-Path ".\packages\electron\static") {
+    Remove-Item ".\packages\electron\static" -Recurse -Force
+}

package/afron/scripts/remove-install.ps1

@@ -0,0 +1,9 @@
+if ((Split-Path -Leaf (Get-Location)) -eq "scripts") {
+    cd ..
+}
+
+Get-ChildItem -Path ".\packages" -Recurse -Directory -Filter "node_modules" | Remove-Item -Recurse -Force
+
+if (Test-Path ".\node_modules") {
+    Remove-Item ".\node_modules" -Recurse -Force
+}

package/afron/scripts/win-vscode.ps1

@@ -0,0 +1,17 @@
+if ((Split-Path -Leaf (Get-Location)) -eq "scripts") {
+    cd ..
+}
+
+Get-Desktop 0 | Switch-Desktop
+code ".\"
+Start-Sleep -Seconds 3
+
+Get-Desktop 1 | Switch-Desktop
+code ".\packages\front"
+Start-Sleep -Seconds 3
+
+Get-Desktop 2 | Switch-Desktop
+code ".\packages\core"
+Start-Sleep -Seconds 3
+
+Get-Desktop 0 | Switch-Desktop

package/dist/bundle.cjs

@@ -114,6 +114,18 @@ class StructJSONTypeLeaf extends BaseJSONTypeLeaf {
         return this;
     }
 }
+class ReplaceJSONTypeLeaf extends BaseJSONTypeLeaf {
+    __brand = 'replace';
+    constructor(tree) {
+        super('replace');
+        this.value['replace'] = tree;
+        this.value['strict'] = false;
+    }
+    strict() {
+        this.value['strict'] = true;
+        return this;
+    }
+}
 
 class ArrayJSONTypeLeaf extends BaseJSONTypeLeaf {
     __brand = 'array';
@@ -166,6 +178,7 @@ const JSONType = {
     Number: () => new NumberJSONTypeLeaf(),
     Bool: () => new BooleanJSONTypeLeaf(),
     Struct: (tree) => new StructJSONTypeLeaf(tree),
+    Replace: (tree) => new ReplaceJSONTypeLeaf(tree),
     Array: (jsonTree) => new ArrayJSONTypeLeaf(jsonTree),
     Any: () => new BaseJSONTypeLeaf('any'),
 };
@@ -290,8 +303,8 @@ class Flattener {
             const { tracePath } = traceResult;
             const reached = tracePath.join(DELIMITER);
             const node = this.navigate.get(reached);
-            // 닿을 수 있는 마지막 노드의 타입이 struct, any 라면 허용됨
-            if (!node || (node.type !== 'struct' && node.type !== 'any')) {
+            // 닿을 수 있는 마지막 노드의 타입이 struct, replace, any 라면 허용됨
+            if (!node || (node.type !== 'struct' && node.type !== 'replace' && node.type !== 'any')) {
                 throw new JSONAccessorError(`Field '${key}' is not allowed`);
             }
             return [[key, value]];
@@ -329,6 +342,10 @@ class Flattener {
                         structData: node,
                     });
                 }
+                else if (node.type === 'replace') {
+                    // replace 타입은 평탄화 없이 전체 값 반환 → 항상 덮어쓰기
+                    return [[newKey, value]];
+                }
                 else if (node.type === 'array') {
                     // @TODO : 배열 타입에 대한 세부 처리 필요
                     // 현재는 배열 경로까지만 flat이 이루어지므로
@@ -452,6 +469,10 @@ class CompatibilityChecker {
                         return true;
                 }
             }
+            // replace 타입은 실제 값이 struct(객체)로 들어옴
+            else if (jsonTypeData.type === 'replace' && targetType === 'struct') {
+                return this.isReplaceCompatible(target, jsonTypeData);
+            }
             else {
                 return false;
             }
@@ -482,6 +503,21 @@ class CompatibilityChecker {
             return false;
         }
     }
+    isReplaceCompatible(struct, replaceTypeData) {
+        if (!replaceTypeData.strict)
+            return true;
+        if (!replaceTypeData.replace)
+            return true;
+        const navigate = r$1.from(replaceTypeData.replace);
+        const flattener = new Flattener(navigate, this);
+        try {
+            flattener.flat({ target: struct, prefix: '' });
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
     getUnionTypeNames(union) {
         return union.candidates.map((c) => {
             if (typeof c === 'object') {
@@ -756,6 +792,11 @@ class JSONAccessor {
         this.#changed = true;
         this.#removeData(key);
     }
+    replaceOne(key, value) {
+        this.#ensureNotDropped();
+        this.#removeData(key);
+        this.set([[key, value]]);
+    }
     remove(keys) {
         this.#ensureNotDropped();
         this.#changed = true;