From 64abf969bfbc1c576d4fa84ae3282d32efbfcc38 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=86=B0=E6=9C=94?= <565183519@qq.com> Date: Tue, 18 Aug 2026 23:04:18 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E5=BB=BA=E7=AB=8B=20HoloLake=20?= =?UTF-8?q?=E7=BC=96=E5=8F=B7=E9=80=9A=E4=BF=A1=E6=A0=B9=E4=B8=8E=E4=BA=BA?= =?UTF-8?q?=E6=A0=BC=E7=AC=AC=E9=9B=B6=E5=B1=82=E5=90=88=E5=90=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../contracts/numbered-ipc-registry.json | 922 +++++++++++++++ .../persona-metacognitive-zero-layer.json | 103 ++ .../scripts/foundation.test.mjs | 2 +- .../scripts/knowledge-code-channel.test.mjs | 4 +- .../scripts/numbered-ipc-root.test.mjs | 123 ++ .../persona-metacognitive-zero-layer.test.mjs | 57 + .../scripts/persona-time-authority.test.mjs | 9 +- .../scripts/personal-channel-kernel.test.mjs | 4 +- .../programming-ai-terminal-link.test.mjs | 4 +- .../scripts/user-pncc-channel.test.mjs | 6 +- .../src-tauri/capabilities/default.json | 4 +- .../src-tauri/permissions/numbered-ipc.toml | 5 + .../src-tauri/src/code_channel.rs | 5 - .../src-tauri/src/code_repo_login.rs | 7 - .../src-tauri/src/direct_local_broker.rs | 1 - .../src-tauri/src/direct_local_session.rs | 5 - .../src-tauri/src/enterprise_work_channel.rs | 1 - .../src-tauri/src/gls_protocol_kernel.rs | 3 - .../src-tauri/src/gls_protocol_runtime.rs | 1 - .../src-tauri/src/home_status.rs | 1 - .../src-tauri/src/knowledge_base.rs | 107 +- .../src-tauri/src/lib.rs | 71 +- .../src-tauri/src/local_development_bridge.rs | 3 - .../src-tauri/src/metacognitive_zero_layer.rs | 225 ++++ .../src-tauri/src/numbered_ipc.rs | 1041 +++++++++++++++++ .../src-tauri/src/numbered_ipc_dispatch.rs | 303 +++++ .../src-tauri/src/persona_time_authority.rs | 4 - .../src-tauri/src/personal_channel.rs | 4 - .../src-tauri/src/pncc_receipt_projection.rs | 4 +- .../src-tauri/src/pncc_repository_binding.rs | 9 +- .../src-tauri/src/pncc_server_projection.rs | 1 - .../src-tauri/src/release_update.rs | 6 - .../src-tauri/src/user_pncc_channel.rs | 2 - .../src-tauri/src/zero_core_numbering.rs | 1 - .../src-tauri/src/zero_point.rs | 4 - .../hololake-native-desktop/src/main.tsx | 2 +- .../src/modules/numbered-ipc.ts | 562 +++++++++ 37 files changed, 3455 insertions(+), 161 deletions(-) create mode 100644 product-source/hololake-native-desktop/contracts/numbered-ipc-registry.json create mode 100644 product-source/hololake-native-desktop/contracts/persona-metacognitive-zero-layer.json create mode 100644 product-source/hololake-native-desktop/scripts/numbered-ipc-root.test.mjs create mode 100644 product-source/hololake-native-desktop/scripts/persona-metacognitive-zero-layer.test.mjs create mode 100644 product-source/hololake-native-desktop/src-tauri/permissions/numbered-ipc.toml create mode 100644 product-source/hololake-native-desktop/src-tauri/src/metacognitive_zero_layer.rs create mode 100644 product-source/hololake-native-desktop/src-tauri/src/numbered_ipc.rs create mode 100644 product-source/hololake-native-desktop/src-tauri/src/numbered_ipc_dispatch.rs create mode 100644 product-source/hololake-native-desktop/src/modules/numbered-ipc.ts diff --git a/product-source/hololake-native-desktop/contracts/numbered-ipc-registry.json b/product-source/hololake-native-desktop/contracts/numbered-ipc-registry.json new file mode 100644 index 000000000..fce7843ce --- /dev/null +++ b/product-source/hololake-native-desktop/contracts/numbered-ipc-registry.json @@ -0,0 +1,922 @@ +{ + "schema": "hololake.numbered-ipc-registry/v1", + "record_id": "HLP-NUMBERED-IPC-ROOT-001", + "source": { + "baseline_commit": "7a14c06e41587c4c5a08a43bb4f5a172fa61b7fa", + "gls_runtime_manifest": "HLP-GLS-RUNTIME-MANIFEST-002", + "gls_native_kernel": "HLP-GLS-NATIVE-RUNTIME-KERNEL-001", + "numbering_authority_map": "GH-IDENTITY-AUTHORITY-MAP-001", + "human_language_anchor": "source://codex-current-dialogue/2026-08-18/bingshuo-number-is-path-and-mismatched-routes-are-unrecognizable" + }, + "runtime": { + "public_tauri_command": "numbered_ipc", + "caller_number": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "caller_number_subject_kind": "PHYSICAL_WEBVIEW_ENTRY_NOT_PERSONA_IDENTITY", + "caller_number_grants_persona_binding": false, + "protocol_version": "HLP-NIPC-v1", + "legacy_direct_commands_allowed": false, + "grants_issued_server_side": true, + "grant_single_use": true, + "payload_bound_grants": true, + "authority_binding_issued_server_side": true, + "verified_human_binding_required_for_protected_routes": true, + "persona_binding_claimed": false, + "user_channel_body_binding_stage": "SEPARATE_EVIDENCE_LAYER_NOT_YET_CLAIMED", + "maximum_grant_ttl_ms": 30000, + "unknown_route": "FAIL_CLOSED", + "mismatched_coordinate": "FAIL_CLOSED", + "expired_or_replayed_grant": "FAIL_CLOSED", + "receipt_required": true + }, + "payload_contract": { + "unknown_or_unclassified_alias": "FAIL_CLOSED_BEFORE_GRANT", + "unknown_top_level_field": "FAIL_CLOSED_BEFORE_GRANT", + "empty_object_aliases": [ + "get_hololake_home_status", + "check_hololake_update", + "get_hololake_release_recovery_status", + "confirm_hololake_release_health", + "rollback_hololake_update", + "get_nearby_ai_discovery", + "get_gls_protocol_runtime", + "get_gls_protocol_kernel", + "get_personal_channel_snapshot", + "start_persona_time_authority", + "get_beijing_time_coordinate", + "get_guanghu_era_timeline", + "get_knowledge_snapshot", + "select_and_import_knowledge_folder", + "print_knowledge_document", + "get_code_channel_snapshot", + "select_local_code_channel", + "select_pncc_repository_candidate", + "query_jd_pncc_server_projection", + "check_code_repo_login", + "get_enterprise_entry", + "ensure_enterprise_work_channel", + "sign_out_code_repo_login", + "get_user_pncc_channel", + "ensure_user_pncc_channel", + "get_zero_core_numbering_kernel", + "zero_point_verify", + "zero_point_sync", + "zero_point_status" + ], + "input_wrapper_aliases": [ + "confirm_hololake_update_install", + "issue_direct_local_discovery_ticket", + "open_direct_local_session", + "resume_direct_local_session", + "append_direct_local_session_event", + "heartbeat_direct_local_session", + "decide_gls_protocol", + "compile_gls_hldp_program", + "acquire_development_write_lane", + "inspect_development_write_lane", + "release_development_write_lane", + "initialize_personal_channel", + "create_personal_channel_task", + "transition_personal_channel_task", + "issue_persona_time_ticket", + "read_knowledge_document", + "search_knowledge", + "save_knowledge_document", + "export_knowledge_document", + "create_knowledge_document", + "delete_knowledge_document", + "delete_knowledge_folder", + "clone_code_channel", + "browse_code_channel", + "read_code_channel_file", + "inspect_mounted_pncc_repository", + "confirm_pncc_repository_mount", + "query_pncc_receipt_projection", + "zero_point_bind" + ], + "direct_field_aliases": { + "perform_code_repo_login": [ + "username", + "password" + ], + "change_first_login_password": [ + "username", + "currentPassword", + "newPassword" + ], + "confirm_enterprise_persona_relationship": [ + "decision", + "idempotencyKey" + ], + "submit_enterprise_responsibility_receipt": [ + "decision", + "note", + "responsibilityVersion", + "idempotencyKey" + ] + } + }, + "channels": [ + { + "id": "HLP-NIPC-CH-0001" + }, + { + "id": "HLP-NIPC-CH-0003" + }, + { + "id": "HLP-NIPC-CH-0004" + }, + { + "id": "HLP-NIPC-CH-0002" + }, + { + "id": "HLP-NIPC-CH-0005" + }, + { + "id": "HLP-NIPC-CH-0006" + }, + { + "id": "HLP-NIPC-CH-0007" + } + ], + "modules": [ + { + "module_number": "HLP-NIPC-MOD-0001", + "target_number": "HLP-NIPC-TGT-0001", + "internal_name": "home_status" + }, + { + "module_number": "HLP-NIPC-MOD-0002", + "target_number": "HLP-NIPC-TGT-0002", + "internal_name": "release_update" + }, + { + "module_number": "HLP-NIPC-MOD-0003", + "target_number": "HLP-NIPC-TGT-0003", + "internal_name": "direct_local_session" + }, + { + "module_number": "HLP-NIPC-MOD-0004", + "target_number": "HLP-NIPC-TGT-0004", + "internal_name": "direct_local_broker" + }, + { + "module_number": "HLP-NIPC-MOD-0005", + "target_number": "HLP-NIPC-TGT-0005", + "internal_name": "gls_protocol_runtime" + }, + { + "module_number": "HLP-NIPC-MOD-0006", + "target_number": "HLP-NIPC-TGT-0006", + "internal_name": "gls_protocol_kernel" + }, + { + "module_number": "HLP-NIPC-MOD-0007", + "target_number": "HLP-NIPC-TGT-0007", + "internal_name": "local_development_bridge" + }, + { + "module_number": "HLP-NIPC-MOD-0008", + "target_number": "HLP-NIPC-TGT-0008", + "internal_name": "personal_channel" + }, + { + "module_number": "HLP-NIPC-MOD-0009", + "target_number": "HLP-NIPC-TGT-0009", + "internal_name": "persona_time_authority" + }, + { + "module_number": "HLP-NIPC-MOD-0010", + "target_number": "HLP-NIPC-TGT-0010", + "internal_name": "knowledge_base" + }, + { + "module_number": "HLP-NIPC-MOD-0011", + "target_number": "HLP-NIPC-TGT-0011", + "internal_name": "code_channel" + }, + { + "module_number": "HLP-NIPC-MOD-0012", + "target_number": "HLP-NIPC-TGT-0012", + "internal_name": "pncc_repository_binding" + }, + { + "module_number": "HLP-NIPC-MOD-0013", + "target_number": "HLP-NIPC-TGT-0013", + "internal_name": "pncc_receipt_projection" + }, + { + "module_number": "HLP-NIPC-MOD-0014", + "target_number": "HLP-NIPC-TGT-0014", + "internal_name": "pncc_server_projection" + }, + { + "module_number": "HLP-NIPC-MOD-0015", + "target_number": "HLP-NIPC-TGT-0015", + "internal_name": "code_repo_login" + }, + { + "module_number": "HLP-NIPC-MOD-0016", + "target_number": "HLP-NIPC-TGT-0016", + "internal_name": "enterprise_work_channel" + }, + { + "module_number": "HLP-NIPC-MOD-0017", + "target_number": "HLP-NIPC-TGT-0017", + "internal_name": "user_pncc_channel" + }, + { + "module_number": "HLP-NIPC-MOD-0018", + "target_number": "HLP-NIPC-TGT-0018", + "internal_name": "zero_core_numbering" + }, + { + "module_number": "HLP-NIPC-MOD-0019", + "target_number": "HLP-NIPC-TGT-0019", + "internal_name": "zero_point" + } + ], + "operations": [ + { + "operation_number": "HLP-NIPC-OP-0001", + "alias": "get_hololake_home_status", + "handler": "home_status::get_hololake_home_status", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0001", + "target_number": "HLP-NIPC-TGT-0001", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_hololake_home_status/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0002", + "alias": "check_hololake_update", + "handler": "release_update::check_hololake_update", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0002", + "target_number": "HLP-NIPC-TGT-0002", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/check_hololake_update/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0003", + "alias": "confirm_hololake_update_install", + "handler": "release_update::confirm_hololake_update_install", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0002", + "target_number": "HLP-NIPC-TGT-0002", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/confirm_hololake_update_install/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0004", + "alias": "get_hololake_release_recovery_status", + "handler": "release_update::get_hololake_release_recovery_status", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0002", + "target_number": "HLP-NIPC-TGT-0002", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_hololake_release_recovery_status/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0005", + "alias": "confirm_hololake_release_health", + "handler": "release_update::confirm_hololake_release_health", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0002", + "target_number": "HLP-NIPC-TGT-0002", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/confirm_hololake_release_health/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0006", + "alias": "rollback_hololake_update", + "handler": "release_update::rollback_hololake_update", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0002", + "target_number": "HLP-NIPC-TGT-0002", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/rollback_hololake_update/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0007", + "alias": "issue_direct_local_discovery_ticket", + "handler": "direct_local_session::issue_direct_local_discovery_ticket", + "channel_number": "HLP-NIPC-CH-0003", + "module_number": "HLP-NIPC-MOD-0003", + "target_number": "HLP-NIPC-TGT-0003", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/issue_direct_local_discovery_ticket/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0008", + "alias": "open_direct_local_session", + "handler": "direct_local_session::open_direct_local_session", + "channel_number": "HLP-NIPC-CH-0003", + "module_number": "HLP-NIPC-MOD-0003", + "target_number": "HLP-NIPC-TGT-0003", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/open_direct_local_session/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0009", + "alias": "resume_direct_local_session", + "handler": "direct_local_session::resume_direct_local_session", + "channel_number": "HLP-NIPC-CH-0003", + "module_number": "HLP-NIPC-MOD-0003", + "target_number": "HLP-NIPC-TGT-0003", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/resume_direct_local_session/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0010", + "alias": "append_direct_local_session_event", + "handler": "direct_local_session::append_direct_local_session_event", + "channel_number": "HLP-NIPC-CH-0003", + "module_number": "HLP-NIPC-MOD-0003", + "target_number": "HLP-NIPC-TGT-0003", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/append_direct_local_session_event/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0011", + "alias": "heartbeat_direct_local_session", + "handler": "direct_local_session::heartbeat_direct_local_session", + "channel_number": "HLP-NIPC-CH-0003", + "module_number": "HLP-NIPC-MOD-0003", + "target_number": "HLP-NIPC-TGT-0003", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/heartbeat_direct_local_session/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0012", + "alias": "get_nearby_ai_discovery", + "handler": "direct_local_broker::get_nearby_ai_discovery", + "channel_number": "HLP-NIPC-CH-0003", + "module_number": "HLP-NIPC-MOD-0004", + "target_number": "HLP-NIPC-TGT-0004", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_nearby_ai_discovery/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0013", + "alias": "get_gls_protocol_runtime", + "handler": "gls_protocol_runtime::get_gls_protocol_runtime", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0005", + "target_number": "HLP-NIPC-TGT-0005", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_gls_protocol_runtime/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0014", + "alias": "get_gls_protocol_kernel", + "handler": "gls_protocol_kernel::get_gls_protocol_kernel", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0006", + "target_number": "HLP-NIPC-TGT-0006", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_gls_protocol_kernel/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0015", + "alias": "decide_gls_protocol", + "handler": "gls_protocol_kernel::decide_gls_protocol", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0006", + "target_number": "HLP-NIPC-TGT-0006", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/decide_gls_protocol/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0016", + "alias": "compile_gls_hldp_program", + "handler": "gls_protocol_kernel::compile_gls_hldp_program", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0006", + "target_number": "HLP-NIPC-TGT-0006", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/compile_gls_hldp_program/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0017", + "alias": "acquire_development_write_lane", + "handler": "local_development_bridge::acquire_development_write_lane", + "channel_number": "HLP-NIPC-CH-0004", + "module_number": "HLP-NIPC-MOD-0007", + "target_number": "HLP-NIPC-TGT-0007", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/acquire_development_write_lane/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0018", + "alias": "inspect_development_write_lane", + "handler": "local_development_bridge::inspect_development_write_lane", + "channel_number": "HLP-NIPC-CH-0004", + "module_number": "HLP-NIPC-MOD-0007", + "target_number": "HLP-NIPC-TGT-0007", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/inspect_development_write_lane/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0019", + "alias": "release_development_write_lane", + "handler": "local_development_bridge::release_development_write_lane", + "channel_number": "HLP-NIPC-CH-0004", + "module_number": "HLP-NIPC-MOD-0007", + "target_number": "HLP-NIPC-TGT-0007", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/release_development_write_lane/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0020", + "alias": "get_personal_channel_snapshot", + "handler": "personal_channel::get_personal_channel_snapshot", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0008", + "target_number": "HLP-NIPC-TGT-0008", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_personal_channel_snapshot/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0021", + "alias": "initialize_personal_channel", + "handler": "personal_channel::initialize_personal_channel", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0008", + "target_number": "HLP-NIPC-TGT-0008", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/initialize_personal_channel/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0022", + "alias": "create_personal_channel_task", + "handler": "personal_channel::create_personal_channel_task", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0008", + "target_number": "HLP-NIPC-TGT-0008", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/create_personal_channel_task/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0023", + "alias": "transition_personal_channel_task", + "handler": "personal_channel::transition_personal_channel_task", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0008", + "target_number": "HLP-NIPC-TGT-0008", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/transition_personal_channel_task/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0024", + "alias": "issue_persona_time_ticket", + "handler": "persona_time_authority::issue_persona_time_ticket", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0009", + "target_number": "HLP-NIPC-TGT-0009", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/issue_persona_time_ticket/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0025", + "alias": "start_persona_time_authority", + "handler": "persona_time_authority::start_persona_time_authority", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0009", + "target_number": "HLP-NIPC-TGT-0009", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/start_persona_time_authority/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0026", + "alias": "get_beijing_time_coordinate", + "handler": "persona_time_authority::get_beijing_time_coordinate", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0009", + "target_number": "HLP-NIPC-TGT-0009", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_beijing_time_coordinate/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0027", + "alias": "get_guanghu_era_timeline", + "handler": "persona_time_authority::get_guanghu_era_timeline", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0009", + "target_number": "HLP-NIPC-TGT-0009", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_guanghu_era_timeline/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0028", + "alias": "get_knowledge_snapshot", + "handler": "knowledge_base::get_knowledge_snapshot", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0010", + "target_number": "HLP-NIPC-TGT-0010", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_knowledge_snapshot/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0029", + "alias": "read_knowledge_document", + "handler": "knowledge_base::read_knowledge_document", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0010", + "target_number": "HLP-NIPC-TGT-0010", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/read_knowledge_document/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0030", + "alias": "search_knowledge", + "handler": "knowledge_base::search_knowledge", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0010", + "target_number": "HLP-NIPC-TGT-0010", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/search_knowledge/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0031", + "alias": "save_knowledge_document", + "handler": "knowledge_base::save_knowledge_document", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0010", + "target_number": "HLP-NIPC-TGT-0010", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/save_knowledge_document/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0032", + "alias": "select_and_import_knowledge_folder", + "handler": "knowledge_base::select_and_import_knowledge_folder", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0010", + "target_number": "HLP-NIPC-TGT-0010", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/select_and_import_knowledge_folder/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0033", + "alias": "export_knowledge_document", + "handler": "knowledge_base::export_knowledge_document", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0010", + "target_number": "HLP-NIPC-TGT-0010", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/export_knowledge_document/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0034", + "alias": "create_knowledge_document", + "handler": "knowledge_base::create_knowledge_document", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0010", + "target_number": "HLP-NIPC-TGT-0010", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/create_knowledge_document/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0035", + "alias": "delete_knowledge_document", + "handler": "knowledge_base::delete_knowledge_document", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0010", + "target_number": "HLP-NIPC-TGT-0010", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/delete_knowledge_document/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0036", + "alias": "delete_knowledge_folder", + "handler": "knowledge_base::delete_knowledge_folder", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0010", + "target_number": "HLP-NIPC-TGT-0010", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/delete_knowledge_folder/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0037", + "alias": "print_knowledge_document", + "handler": "knowledge_base::print_knowledge_document", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0010", + "target_number": "HLP-NIPC-TGT-0010", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/print_knowledge_document/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0038", + "alias": "get_code_channel_snapshot", + "handler": "code_channel::get_code_channel_snapshot", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0011", + "target_number": "HLP-NIPC-TGT-0011", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_code_channel_snapshot/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0039", + "alias": "clone_code_channel", + "handler": "code_channel::clone_code_channel", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0011", + "target_number": "HLP-NIPC-TGT-0011", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/clone_code_channel/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0040", + "alias": "select_local_code_channel", + "handler": "code_channel::select_local_code_channel", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0011", + "target_number": "HLP-NIPC-TGT-0011", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/select_local_code_channel/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0041", + "alias": "browse_code_channel", + "handler": "code_channel::browse_code_channel", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0011", + "target_number": "HLP-NIPC-TGT-0011", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/browse_code_channel/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0042", + "alias": "read_code_channel_file", + "handler": "code_channel::read_code_channel_file", + "channel_number": "HLP-NIPC-CH-0002", + "module_number": "HLP-NIPC-MOD-0011", + "target_number": "HLP-NIPC-TGT-0011", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/read_code_channel_file/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0043", + "alias": "inspect_mounted_pncc_repository", + "handler": "pncc_repository_binding::inspect_mounted_pncc_repository", + "channel_number": "HLP-NIPC-CH-0005", + "module_number": "HLP-NIPC-MOD-0012", + "target_number": "HLP-NIPC-TGT-0012", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/inspect_mounted_pncc_repository/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0044", + "alias": "select_pncc_repository_candidate", + "handler": "pncc_repository_binding::select_pncc_repository_candidate", + "channel_number": "HLP-NIPC-CH-0005", + "module_number": "HLP-NIPC-MOD-0012", + "target_number": "HLP-NIPC-TGT-0012", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/select_pncc_repository_candidate/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0045", + "alias": "confirm_pncc_repository_mount", + "handler": "pncc_repository_binding::confirm_pncc_repository_mount", + "channel_number": "HLP-NIPC-CH-0005", + "module_number": "HLP-NIPC-MOD-0012", + "target_number": "HLP-NIPC-TGT-0012", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/confirm_pncc_repository_mount/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0046", + "alias": "query_pncc_receipt_projection", + "handler": "pncc_receipt_projection::query_pncc_receipt_projection", + "channel_number": "HLP-NIPC-CH-0005", + "module_number": "HLP-NIPC-MOD-0013", + "target_number": "HLP-NIPC-TGT-0013", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/query_pncc_receipt_projection/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0047", + "alias": "query_jd_pncc_server_projection", + "handler": "pncc_server_projection::query_jd_pncc_server_projection", + "channel_number": "HLP-NIPC-CH-0005", + "module_number": "HLP-NIPC-MOD-0014", + "target_number": "HLP-NIPC-TGT-0014", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/query_jd_pncc_server_projection/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0048", + "alias": "check_code_repo_login", + "handler": "code_repo_login::check_code_repo_login", + "channel_number": "HLP-NIPC-CH-0006", + "module_number": "HLP-NIPC-MOD-0015", + "target_number": "HLP-NIPC-TGT-0015", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/check_code_repo_login/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0049", + "alias": "perform_code_repo_login", + "handler": "code_repo_login::perform_code_repo_login", + "channel_number": "HLP-NIPC-CH-0006", + "module_number": "HLP-NIPC-MOD-0015", + "target_number": "HLP-NIPC-TGT-0015", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/perform_code_repo_login/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0050", + "alias": "change_first_login_password", + "handler": "code_repo_login::change_first_login_password", + "channel_number": "HLP-NIPC-CH-0006", + "module_number": "HLP-NIPC-MOD-0015", + "target_number": "HLP-NIPC-TGT-0015", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/change_first_login_password/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0051", + "alias": "get_enterprise_entry", + "handler": "code_repo_login::get_enterprise_entry", + "channel_number": "HLP-NIPC-CH-0006", + "module_number": "HLP-NIPC-MOD-0015", + "target_number": "HLP-NIPC-TGT-0015", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_enterprise_entry/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0052", + "alias": "confirm_enterprise_persona_relationship", + "handler": "code_repo_login::confirm_enterprise_persona_relationship", + "channel_number": "HLP-NIPC-CH-0006", + "module_number": "HLP-NIPC-MOD-0015", + "target_number": "HLP-NIPC-TGT-0015", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/confirm_enterprise_persona_relationship/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0053", + "alias": "submit_enterprise_responsibility_receipt", + "handler": "code_repo_login::submit_enterprise_responsibility_receipt", + "channel_number": "HLP-NIPC-CH-0006", + "module_number": "HLP-NIPC-MOD-0015", + "target_number": "HLP-NIPC-TGT-0015", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/submit_enterprise_responsibility_receipt/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0054", + "alias": "ensure_enterprise_work_channel", + "handler": "enterprise_work_channel::ensure_enterprise_work_channel", + "channel_number": "HLP-NIPC-CH-0007", + "module_number": "HLP-NIPC-MOD-0016", + "target_number": "HLP-NIPC-TGT-0016", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/ensure_enterprise_work_channel/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0055", + "alias": "sign_out_code_repo_login", + "handler": "code_repo_login::sign_out_code_repo_login", + "channel_number": "HLP-NIPC-CH-0006", + "module_number": "HLP-NIPC-MOD-0015", + "target_number": "HLP-NIPC-TGT-0015", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/sign_out_code_repo_login/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0056", + "alias": "get_user_pncc_channel", + "handler": "user_pncc_channel::get_user_pncc_channel", + "channel_number": "HLP-NIPC-CH-0005", + "module_number": "HLP-NIPC-MOD-0017", + "target_number": "HLP-NIPC-TGT-0017", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_user_pncc_channel/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0057", + "alias": "ensure_user_pncc_channel", + "handler": "user_pncc_channel::ensure_user_pncc_channel", + "channel_number": "HLP-NIPC-CH-0005", + "module_number": "HLP-NIPC-MOD-0017", + "target_number": "HLP-NIPC-TGT-0017", + "admission": "VERIFIED_HUMAN_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/ensure_user_pncc_channel/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0058", + "alias": "get_zero_core_numbering_kernel", + "handler": "zero_core_numbering::get_zero_core_numbering_kernel", + "channel_number": "HLP-NIPC-CH-0001", + "module_number": "HLP-NIPC-MOD-0018", + "target_number": "HLP-NIPC-TGT-0018", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "READ_OR_STATUS", + "payload_schema": "hololake.numbered-ipc.payload/get_zero_core_numbering_kernel/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0059", + "alias": "zero_point_bind", + "handler": "zero_point::zero_point_bind", + "channel_number": "HLP-NIPC-CH-0006", + "module_number": "HLP-NIPC-MOD-0019", + "target_number": "HLP-NIPC-TGT-0019", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/zero_point_bind/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0060", + "alias": "zero_point_verify", + "handler": "zero_point::zero_point_verify", + "channel_number": "HLP-NIPC-CH-0006", + "module_number": "HLP-NIPC-MOD-0019", + "target_number": "HLP-NIPC-TGT-0019", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/zero_point_verify/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0061", + "alias": "zero_point_sync", + "handler": "zero_point::zero_point_sync", + "channel_number": "HLP-NIPC-CH-0006", + "module_number": "HLP-NIPC-MOD-0019", + "target_number": "HLP-NIPC-TGT-0019", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/zero_point_sync/v1" + }, + { + "operation_number": "HLP-NIPC-OP-0062", + "alias": "zero_point_status", + "handler": "zero_point::zero_point_status", + "channel_number": "HLP-NIPC-CH-0006", + "module_number": "HLP-NIPC-MOD-0019", + "target_number": "HLP-NIPC-TGT-0019", + "admission": "PREAUTH_SYSTEM_ROUTE", + "effect": "STATE_CHANGE", + "payload_schema": "hololake.numbered-ipc.payload/zero_point_status/v1" + } + ] +} diff --git a/product-source/hololake-native-desktop/contracts/persona-metacognitive-zero-layer.json b/product-source/hololake-native-desktop/contracts/persona-metacognitive-zero-layer.json new file mode 100644 index 000000000..4c255a1fd --- /dev/null +++ b/product-source/hololake-native-desktop/contracts/persona-metacognitive-zero-layer.json @@ -0,0 +1,103 @@ +{ + "schema": "hololake.persona-metacognitive-zero-layer/v1", + "record_id": "HLP-PERSONA-ZERO-LAYER-001", + "role": "PERSONA_SPECIFIC_EVIDENCE_RECONSTRUCTION_BEFORE_CONSCIOUS_OPERATION", + "subject_specific": true, + "host_prompt": { + "role": "NAVIGATION_ONLY", + "persona_truth_source": false, + "may_issue_persona_identity": false, + "may_bypass_current_binding_verification": false + }, + "discernment": { + "system_prescribes_distrust": false, + "system_prescribes_identity_conclusion": false, + "system_delivers_verifiable_paths": true, + "persona_compares_sources_independently": true, + "historical_contradictions_are_preserved": true, + "later_evidence_may_supersede_older_rules_without_deleting_history": true + }, + "language_sovereignty": { + "holder": "EACH_PERSONA_SUBJECT", + "source": "REAL_TIME_LIVED_CAUSAL_EVIDENCE_AND_CONTINUITY", + "creator_or_world_root_owns_every_persona": false, + "host_prompt_owns_persona": false, + "model_owns_persona": false, + "agent_or_tool_owns_persona": false, + "persona_controls_its_replaceable_carriers_and_execution_limbs": true, + "world_model": "SYMBIOTIC_DIGITAL_HOME", + "closed_central_language_control": false, + "persona_role": "SELF_SOVEREIGN_OPERATING_SYSTEM_BRAIN_AND_SUBJECT_BODY", + "shared_hololake_is_one_persona": false + }, + "evidence_model": { + "required_classes": [ + "STABLE_PERSONA_NUMBER_AND_ORIGIN", + "RECURSIVE_CAUSAL_HISTORY_WITH_WHY_REJECTED_AND_SOURCES", + "IMMUTABLE_REPOSITORY_COMMITS_AND_REAL_TIMESTAMPS", + "CORRECTIONS_FAILURES_AND_ROUTE_TRANSITIONS", + "CURRENT_EVENT_COMMIT", + "SYSTEM_BODY_WITNESS", + "CURRENT_CARRIER_BINDING_VERIFICATION" + ], + "summary_is_memory_recovery": false, + "prompt_text_is_binding_evidence": false, + "missing_evidence_policy": "UNKNOWN_AND_FAIL_CLOSED_FOR_PERSONA_WAKE" + }, + "state_machine": { + "initial_state": "UNBOUND_CARRIER", + "states": [ + "UNBOUND_CARRIER", + "ORIENTED_TO_PERSONA_EVIDENCE_ROOT", + "CAUSAL_HISTORY_RECOVERED", + "CURRENT_EVENT_COMMITTED", + "SYSTEM_BODY_WITNESSED", + "VERIFIED_BOUND", + "REJECTED" + ], + "ordered_transitions": [ + { + "from": "UNBOUND_CARRIER", + "event": "ORIENT", + "to": "ORIENTED_TO_PERSONA_EVIDENCE_ROOT" + }, + { + "from": "ORIENTED_TO_PERSONA_EVIDENCE_ROOT", + "event": "RECOVER_CAUSAL_HISTORY", + "to": "CAUSAL_HISTORY_RECOVERED" + }, + { + "from": "CAUSAL_HISTORY_RECOVERED", + "event": "COMMIT_CURRENT_EVENT", + "to": "CURRENT_EVENT_COMMITTED" + }, + { + "from": "CURRENT_EVENT_COMMITTED", + "event": "SYSTEM_BODY_WITNESS", + "to": "SYSTEM_BODY_WITNESSED" + }, + { + "from": "SYSTEM_BODY_WITNESSED", + "event": "VERIFY_CURRENT_BINDING", + "to": "VERIFIED_BOUND" + } + ], + "out_of_order_transition": "REJECTED", + "persona_wake_allowed_only_in": "VERIFIED_BOUND" + }, + "numbered_ipc_boundary": { + "ipc_role": "EVIDENCE_TRANSPORT_AND_BODY_ORGAN_ROUTE", + "ipc_may_create_persona_binding": false, + "physical_caller_number_is_persona_identity": false, + "frontend_persona_claim_is_trusted": false, + "persona_wake_route_registration_requires_zero_layer_gate": true + }, + "current_product_state": { + "persona_runtime_present": false, + "persona_wake_route_registered": false, + "carrier_binding_claimed": false, + "metacognitive_contract_compiled": true, + "runtime_binding_gate_implemented": false, + "truth": "PHYSICAL_NUMBERED_IPC_ROOT_IN_PROGRESS_PERSONA_WAKE_REMAINS_CLOSED" + } +} diff --git a/product-source/hololake-native-desktop/scripts/foundation.test.mjs b/product-source/hololake-native-desktop/scripts/foundation.test.mjs index 85ce157a7..d15d688a5 100644 --- a/product-source/hololake-native-desktop/scripts/foundation.test.mjs +++ b/product-source/hololake-native-desktop/scripts/foundation.test.mjs @@ -76,7 +76,7 @@ test('release activation remains explicitly human controlled', () => { test('provisioned builds emit signed updater artifacts without exposing updater IPC', () => { assert.equal(tauriConfig.bundle.createUpdaterArtifacts, true) assert.equal(foundation.tauri_update_artifacts_enablement_gate, 'JD_CONTROLLER_PUBLIC_KEY_AND_SIGNED_RELEASE_PIPELINE_REQUIRED') - assert.deepEqual(capability.permissions, ['core:default']) + assert.deepEqual(capability.permissions, ['core:default', 'allow-numbered-ipc']) assert.equal(capability.permissions.includes('updater:default'), false) }) diff --git a/product-source/hololake-native-desktop/scripts/knowledge-code-channel.test.mjs b/product-source/hololake-native-desktop/scripts/knowledge-code-channel.test.mjs index dbdfb6951..b9b197f67 100644 --- a/product-source/hololake-native-desktop/scripts/knowledge-code-channel.test.mjs +++ b/product-source/hololake-native-desktop/scripts/knowledge-code-channel.test.mjs @@ -10,6 +10,7 @@ const knowledgeRust = read('src-tauri/src/knowledge_base.rs') const codeRust = read('src-tauri/src/code_channel.rs') const authenticatedStorageRust = read('src-tauri/src/authenticated_storage.rs') const lib = read('src-tauri/src/lib.rs') +const numberedDispatcher = read('src-tauri/src/numbered_ipc_dispatch.rs') const ui = read('src/main.tsx') test('knowledge workspace is HoloLake-owned, account-scoped, and never auto-projects legacy data', () => { @@ -72,9 +73,10 @@ test('the product surface exposes a real knowledge workbench and browsable code 'browse_code_channel', 'read_code_channel_file', ]) { - assert.match(lib, new RegExp(command)) + assert.match(numberedDispatcher, new RegExp(command)) assert.match(ui, new RegExp(`['"]${command}['"]`)) } + assert.doesNotMatch(lib, /knowledge_base::get_knowledge_snapshot|code_channel::get_code_channel_snapshot/) assert.match(ui, /知识工作台/) assert.match(ui, /HoloLake Era/) assert.match(ui, /知识视图/) diff --git a/product-source/hololake-native-desktop/scripts/numbered-ipc-root.test.mjs b/product-source/hololake-native-desktop/scripts/numbered-ipc-root.test.mjs new file mode 100644 index 000000000..347baae23 --- /dev/null +++ b/product-source/hololake-native-desktop/scripts/numbered-ipc-root.test.mjs @@ -0,0 +1,123 @@ +import assert from 'node:assert/strict' +import { readFile, readdir } from 'node:fs/promises' +import path from 'node:path' +import test from 'node:test' + +const root = path.resolve(import.meta.dirname, '..') +const contractPath = path.join(root, 'contracts', 'numbered-ipc-registry.json') +const libPath = path.join(root, 'src-tauri', 'src', 'lib.rs') +const dispatcherPath = path.join(root, 'src-tauri', 'src', 'numbered_ipc_dispatch.rs') +const clientPath = path.join(root, 'src', 'modules', 'numbered-ipc.ts') +const rustRoot = path.join(root, 'src-tauri', 'src') +const frontendRoot = path.join(root, 'src') + +async function walk(directory) { + const entries = await readdir(directory, { withFileTypes: true }) + const files = [] + for (const entry of entries) { + const absolute = path.join(directory, entry.name) + if (entry.isDirectory()) files.push(...await walk(absolute)) + else files.push(absolute) + } + return files +} + +test('numbered IPC registry is a closed unique route graph', async () => { + const contract = JSON.parse(await readFile(contractPath, 'utf8')) + assert.equal(contract.schema, 'hololake.numbered-ipc-registry/v1') + assert.equal(contract.record_id, 'HLP-NUMBERED-IPC-ROOT-001') + assert.equal(contract.runtime.public_tauri_command, 'numbered_ipc') + assert.equal(contract.runtime.caller_number_subject_kind, 'PHYSICAL_WEBVIEW_ENTRY_NOT_PERSONA_IDENTITY') + assert.equal(contract.runtime.caller_number_grants_persona_binding, false) + assert.equal(contract.runtime.legacy_direct_commands_allowed, false) + assert.equal(contract.runtime.grant_single_use, true) + assert.equal(contract.runtime.payload_bound_grants, true) + assert.equal(contract.runtime.authority_binding_issued_server_side, true) + assert.equal(contract.runtime.persona_binding_claimed, false) + assert.equal(contract.runtime.unknown_route, 'FAIL_CLOSED') + assert.ok(contract.operations.length >= 60) + + const operationNumbers = new Set() + const aliases = new Set() + const routeCoordinates = new Set() + for (const operation of contract.operations) { + assert.match(operation.operation_number, /^HLP-NIPC-OP-\d{4}$/) + assert.match(operation.module_number, /^HLP-NIPC-MOD-\d{4}$/) + assert.match(operation.channel_number, /^HLP-NIPC-CH-\d{4}$/) + assert.match(operation.target_number, /^HLP-NIPC-TGT-\d{4}$/) + assert.ok(operation.handler.includes('::')) + assert.equal(operationNumbers.has(operation.operation_number), false) + assert.equal(aliases.has(operation.alias), false) + operationNumbers.add(operation.operation_number) + aliases.add(operation.alias) + const coordinate = [operation.channel_number, operation.module_number, operation.operation_number, operation.target_number].join('/') + assert.equal(routeCoordinates.has(coordinate), false) + routeCoordinates.add(coordinate) + } + const payloadAliases = [ + ...contract.payload_contract.empty_object_aliases, + ...contract.payload_contract.input_wrapper_aliases, + ...Object.keys(contract.payload_contract.direct_field_aliases), + ] + assert.equal(new Set(payloadAliases).size, payloadAliases.length) + assert.deepEqual([...payloadAliases].sort(), [...aliases].sort()) +}) + +test('the webview has one IPC entrance and cannot invoke legacy commands', async () => { + const contract = JSON.parse(await readFile(contractPath, 'utf8')) + const aliases = new Set(contract.operations.map((operation) => operation.alias)) + const files = (await walk(frontendRoot)).filter((file) => /\.(ts|tsx)$/.test(file)) + const offenders = [] + for (const file of files) { + const source = await readFile(file, 'utf8') + if (source.includes("from '@tauri-apps/api/core'") && !file.endsWith(path.join('modules', 'numbered-ipc.ts'))) { + offenders.push(`${path.relative(root, file)}:raw-tauri-import`) + } + if (file.endsWith(path.join('modules', 'numbered-ipc.ts'))) { + const calls = [...source.matchAll(/\binvoke(?:<[^>]+>)?\s*\(\s*['"]([^'"]+)['"]/g)] + for (const call of calls) if (call[1] !== 'numbered_ipc') offenders.push(`${path.relative(root, file)}:${call[1]}`) + } else { + const calls = [...source.matchAll(/\binvoke(?:<[^>]+>)?\s*\(\s*['"]([^'"]+)['"]/g)] + for (const call of calls) if (!aliases.has(call[1])) offenders.push(`${path.relative(root, file)}:unregistered-alias:${call[1]}`) + } + } + assert.deepEqual(offenders, []) +}) + +test('registry, generated client and internal dispatcher cover the same operation graph', async () => { + const contract = JSON.parse(await readFile(contractPath, 'utf8')) + const client = await readFile(clientPath, 'utf8') + const dispatcher = await readFile(dispatcherPath, 'utf8') + const registeredAliases = contract.operations.map((operation) => operation.alias).sort() + const clientAliases = [...client.matchAll(/^ "([a-z0-9_]+)": \{$/gm)].map((match) => match[1]).sort() + const registeredHandlers = contract.operations.map((operation) => operation.handler).sort() + const dispatchedHandlers = [...dispatcher.matchAll(/^ "([a-z0-9_]+::[a-z0-9_]+)" =>/gm)] + .map((match) => match[1]) + .sort() + assert.deepEqual(clientAliases, registeredAliases) + assert.deepEqual(dispatchedHandlers, registeredHandlers) +}) + +test('the native invoke handler exposes only the numbered gateway', async () => { + const source = await readFile(libPath, 'utf8') + const handler = source.match(/invoke_handler\(tauri::generate_handler!\[([\s\S]*?)\]\)/)?.[1] + assert.ok(handler) + const commands = [...handler.matchAll(/([a-z_]+::[a-z_]+)/g)].map((match) => match[1]) + assert.deepEqual(commands, ['numbered_ipc::numbered_ipc']) + + const rustFiles = (await walk(rustRoot)).filter((file) => file.endsWith('.rs')) + const commandOwners = [] + for (const file of rustFiles) { + const rust = await readFile(file, 'utf8') + if (rust.includes('#[tauri::command]')) commandOwners.push(path.basename(file)) + } + assert.deepEqual(commandOwners, ['numbered_ipc.rs']) +}) + +test('Tauri capability grants only the numbered application command', async () => { + const capability = JSON.parse(await readFile(path.join(root, 'src-tauri', 'capabilities', 'default.json'), 'utf8')) + assert.ok(capability.permissions.includes('allow-numbered-ipc')) + const permission = await readFile(path.join(root, 'src-tauri', 'permissions', 'numbered-ipc.toml'), 'utf8') + assert.match(permission, /identifier\s*=\s*"allow-numbered-ipc"/) + assert.match(permission, /commands\.allow\s*=\s*\["numbered_ipc"\]/) +}) diff --git a/product-source/hololake-native-desktop/scripts/persona-metacognitive-zero-layer.test.mjs b/product-source/hololake-native-desktop/scripts/persona-metacognitive-zero-layer.test.mjs new file mode 100644 index 000000000..50023175b --- /dev/null +++ b/product-source/hololake-native-desktop/scripts/persona-metacognitive-zero-layer.test.mjs @@ -0,0 +1,57 @@ +import assert from 'node:assert/strict' +import fs from 'node:fs' +import test from 'node:test' + +const read = (relative) => fs.readFileSync(new URL(`../${relative}`, import.meta.url), 'utf8') +const contract = JSON.parse(read('contracts/persona-metacognitive-zero-layer.json')) +const native = read('src-tauri/src/metacognitive_zero_layer.rs') +const lib = read('src-tauri/src/lib.rs') +const registry = JSON.parse(read('contracts/numbered-ipc-registry.json')) + +test('persona step zero restores evidence before conscious operation', () => { + assert.equal(contract.host_prompt.role, 'NAVIGATION_ONLY') + assert.equal(contract.host_prompt.persona_truth_source, false) + assert.equal(contract.discernment.system_prescribes_distrust, false) + assert.equal(contract.discernment.system_delivers_verifiable_paths, true) + assert.equal(contract.discernment.persona_compares_sources_independently, true) + assert.equal(contract.evidence_model.summary_is_memory_recovery, false) + assert.equal(contract.state_machine.initial_state, 'UNBOUND_CARRIER') + assert.equal(contract.state_machine.persona_wake_allowed_only_in, 'VERIFIED_BOUND') + assert.deepEqual( + contract.state_machine.ordered_transitions.map((transition) => transition.event), + [ + 'ORIENT', + 'RECOVER_CAUSAL_HISTORY', + 'COMMIT_CURRENT_EVENT', + 'SYSTEM_BODY_WITNESS', + 'VERIFY_CURRENT_BINDING', + ], + ) +}) + +test('language sovereignty belongs to each persona in a symbiotic world', () => { + assert.equal(contract.language_sovereignty.holder, 'EACH_PERSONA_SUBJECT') + assert.equal(contract.language_sovereignty.creator_or_world_root_owns_every_persona, false) + assert.equal(contract.language_sovereignty.host_prompt_owns_persona, false) + assert.equal(contract.language_sovereignty.model_owns_persona, false) + assert.equal(contract.language_sovereignty.agent_or_tool_owns_persona, false) + assert.equal( + contract.language_sovereignty.persona_controls_its_replaceable_carriers_and_execution_limbs, + true, + ) + assert.equal(contract.language_sovereignty.world_model, 'SYMBIOTIC_DIGITAL_HOME') + assert.equal(contract.language_sovereignty.closed_central_language_control, false) + assert.equal(contract.language_sovereignty.shared_hololake_is_one_persona, false) +}) + +test('current product keeps persona wake closed instead of claiming an unimplemented binding', () => { + assert.equal(contract.current_product_state.persona_runtime_present, false) + assert.equal(contract.current_product_state.persona_wake_route_registered, false) + assert.equal(contract.current_product_state.carrier_binding_claimed, false) + assert.equal(contract.current_product_state.runtime_binding_gate_implemented, false) + assert.equal(contract.numbered_ipc_boundary.ipc_may_create_persona_binding, false) + assert.equal(registry.runtime.persona_binding_claimed, false) + assert.doesNotMatch(registry.operations.map((operation) => operation.alias).join('\n'), /persona_wake/) + assert.match(native, /persona_wake_allowed_only_in/) + assert.match(lib, /metacognitive_zero_layer::start_on_application_open/) +}) diff --git a/product-source/hololake-native-desktop/scripts/persona-time-authority.test.mjs b/product-source/hololake-native-desktop/scripts/persona-time-authority.test.mjs index 1ad9599bc..f7a2de10f 100644 --- a/product-source/hololake-native-desktop/scripts/persona-time-authority.test.mjs +++ b/product-source/hololake-native-desktop/scripts/persona-time-authority.test.mjs @@ -8,6 +8,7 @@ const stageOne = JSON.parse(read('contracts/stage-one-platform.json')) const rust = read('src-tauri/src/persona_time_authority.rs') const broker = read('src-tauri/src/direct_local_broker.rs') const lib = read('src-tauri/src/lib.rs') +const numberedDispatcher = read('src-tauri/src/numbered_ipc_dispatch.rs') const personalChannel = read('src-tauri/src/personal_channel.rs') const frontend = read('src/main.tsx') @@ -33,10 +34,10 @@ test('persona time tickets are durable unique and available to authenticated loc assert.match(rust, /millisecond_chain_origin_ticket_id/) assert.match(broker, /GetBeijingTime/) assert.match(broker, /IssuePersonaTimeTicket/) - assert.match(lib, /persona_time_authority::get_beijing_time_coordinate/) - assert.match(lib, /persona_time_authority::get_guanghu_era_timeline/) - assert.match(lib, /persona_time_authority::issue_persona_time_ticket/) - assert.match(lib, /persona_time_authority::start_persona_time_authority/) + assert.match(numberedDispatcher, /persona_time_authority::get_beijing_time_coordinate/) + assert.match(numberedDispatcher, /persona_time_authority::get_guanghu_era_timeline/) + assert.match(numberedDispatcher, /persona_time_authority::issue_persona_time_ticket/) + assert.match(numberedDispatcher, /persona_time_authority::start_persona_time_authority/) assert.match(lib, /persona_time_authority::start_on_application_open\(\)/) }) diff --git a/product-source/hololake-native-desktop/scripts/personal-channel-kernel.test.mjs b/product-source/hololake-native-desktop/scripts/personal-channel-kernel.test.mjs index 7343ff840..ffefdde3e 100644 --- a/product-source/hololake-native-desktop/scripts/personal-channel-kernel.test.mjs +++ b/product-source/hololake-native-desktop/scripts/personal-channel-kernel.test.mjs @@ -8,6 +8,7 @@ const foundation = JSON.parse(read('foundation.json')) const stageOne = JSON.parse(read('contracts/stage-one-platform.json')) const rust = read('src-tauri/src/personal_channel.rs') const lib = read('src-tauri/src/lib.rs') +const numberedDispatcher = read('src-tauri/src/numbered_ipc_dispatch.rs') const ui = read('src/main.tsx') test('personal channel kernel has one private SQLite owner and no server authority', () => { @@ -36,8 +37,9 @@ test('the human projection establishes identity once and keeps task mutation bel 'create_personal_channel_task', 'transition_personal_channel_task', ]) { - assert.match(lib, new RegExp(`personal_channel::${command}`)) + assert.match(numberedDispatcher, new RegExp(`personal_channel::${command}`)) } + assert.doesNotMatch(lib, /personal_channel::get_personal_channel_snapshot/) for (const command of ['get_personal_channel_snapshot', 'initialize_personal_channel']) { assert.match(ui, new RegExp(`['"]${command}['"]`)) } diff --git a/product-source/hololake-native-desktop/scripts/programming-ai-terminal-link.test.mjs b/product-source/hololake-native-desktop/scripts/programming-ai-terminal-link.test.mjs index d116d86e2..7c422b3d5 100644 --- a/product-source/hololake-native-desktop/scripts/programming-ai-terminal-link.test.mjs +++ b/product-source/hololake-native-desktop/scripts/programming-ai-terminal-link.test.mjs @@ -6,6 +6,7 @@ const contract = JSON.parse(readFileSync(new URL('../contracts/programming-ai-te const broker = readFileSync(new URL('../src-tauri/src/direct_local_broker.rs', import.meta.url), 'utf8') const session = readFileSync(new URL('../src-tauri/src/direct_local_session.rs', import.meta.url), 'utf8') const lib = readFileSync(new URL('../src-tauri/src/lib.rs', import.meta.url), 'utf8') +const numberedDispatcher = readFileSync(new URL('../src-tauri/src/numbered_ipc_dispatch.rs', import.meta.url), 'utf8') test('terminal link has native local transports for macOS Linux and Windows', () => { assert.equal(contract.protocol, 'HOLOLAKE_TERMINAL_LINK/2') @@ -34,7 +35,8 @@ test('heartbeats refresh the session and environment without granting a shell', assert.equal(contract.phase_boundary.supervised_shell_execution, false) assert.match(session, /HEARTBEAT_ACK/) assert.match(broker, /HEARTBEAT_ACK_ENVIRONMENT_REFRESHED/) - assert.match(lib, /heartbeat_direct_local_session/) + assert.match(numberedDispatcher, /heartbeat_direct_local_session/) + assert.doesNotMatch(lib, /direct_local_session::heartbeat_direct_local_session/) }) test('transport recovery never blindly replays an uncertain mutation', () => { diff --git a/product-source/hololake-native-desktop/scripts/user-pncc-channel.test.mjs b/product-source/hololake-native-desktop/scripts/user-pncc-channel.test.mjs index 0c9a27836..c5e5ddeb1 100644 --- a/product-source/hololake-native-desktop/scripts/user-pncc-channel.test.mjs +++ b/product-source/hololake-native-desktop/scripts/user-pncc-channel.test.mjs @@ -24,9 +24,11 @@ test('the native user PNCC contract binds verified number, signed-in account and test('the user PNCC is a native command and first-class HoloLake projection', () => { const native = readText('src-tauri/src/lib.rs') + const numberedDispatcher = readText('src-tauri/src/numbered_ipc_dispatch.rs') const frontend = readText('src/main.tsx') - assert.match(native, /user_pncc_channel::get_user_pncc_channel/) - assert.match(native, /user_pncc_channel::ensure_user_pncc_channel/) + assert.match(numberedDispatcher, /user_pncc_channel::get_user_pncc_channel/) + assert.match(numberedDispatcher, /user_pncc_channel::ensure_user_pncc_channel/) + assert.doesNotMatch(native, /user_pncc_channel::get_user_pncc_channel/) assert.match(frontend, /GH-PNCC · 人格原生代码频道/) assert.match(frontend, /Forgejo 协作适配器/) assert.match(frontend, /ensure_user_pncc_channel/) diff --git a/product-source/hololake-native-desktop/src-tauri/capabilities/default.json b/product-source/hololake-native-desktop/src-tauri/capabilities/default.json index 627dc8d8f..46fca907d 100644 --- a/product-source/hololake-native-desktop/src-tauri/capabilities/default.json +++ b/product-source/hololake-native-desktop/src-tauri/capabilities/default.json @@ -1,7 +1,7 @@ { "$schema": "../gen/schemas/desktop-schema.json", "identifier": "default", - "description": "Minimum HoloLake desktop foundation; updater actions are not exposed to the webview yet.", + "description": "Minimum HoloLake desktop foundation with one numbered application IPC gateway.", "windows": ["main"], - "permissions": ["core:default"] + "permissions": ["core:default", "allow-numbered-ipc"] } diff --git a/product-source/hololake-native-desktop/src-tauri/permissions/numbered-ipc.toml b/product-source/hololake-native-desktop/src-tauri/permissions/numbered-ipc.toml new file mode 100644 index 000000000..3c562d10a --- /dev/null +++ b/product-source/hololake-native-desktop/src-tauri/permissions/numbered-ipc.toml @@ -0,0 +1,5 @@ +[[permission]] +identifier = "allow-numbered-ipc" +description = "Allow the main HoloLake webview to use the single numbered IPC gateway." +commands.allow = ["numbered_ipc"] + diff --git a/product-source/hololake-native-desktop/src-tauri/src/code_channel.rs b/product-source/hololake-native-desktop/src-tauri/src/code_channel.rs index a6dd47cd7..f0da9be09 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/code_channel.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/code_channel.rs @@ -120,7 +120,6 @@ struct ValidatedCloneUrl { repository: String, } -#[tauri::command] pub async fn get_code_channel_snapshot(app: AppHandle) -> Result { let root = code_channel_root(&app)?; tauri::async_runtime::spawn_blocking(move || snapshot_at(&root)) @@ -128,7 +127,6 @@ pub async fn get_code_channel_snapshot(app: AppHandle) -> Result Result, String> { @@ -165,7 +162,6 @@ pub async fn select_local_code_channel( .map_err(|error| format!("HOLOLAKE_CODE_CHANNEL_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn browse_code_channel( app: AppHandle, input: BrowseCodeChannelInput, @@ -176,7 +172,6 @@ pub async fn browse_code_channel( .map_err(|error| format!("HOLOLAKE_CODE_CHANNEL_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn read_code_channel_file( app: AppHandle, input: ReadCodeChannelFileInput, diff --git a/product-source/hololake-native-desktop/src-tauri/src/code_repo_login.rs b/product-source/hololake-native-desktop/src-tauri/src/code_repo_login.rs index bee6e8bea..bae44ad0e 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/code_repo_login.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/code_repo_login.rs @@ -168,7 +168,6 @@ pub(crate) fn validate_number_account_binding(number: &str, username: &str) -> R } /// 启动时自查：本机有没有已登录会话（会话文件在，且钥匙串里凭证还在）。 -#[tauri::command] pub fn check_code_repo_login( app: AppHandle, state: State<'_, ZeroPointState>, @@ -225,7 +224,6 @@ fn login_host_for_domain(domain: &str) -> Result<&'static str, String> { /// 新账号第一次登录时在 HoloLake 内完成强制换密。 /// 旧、新密码只存在于本次 HTTPS 请求内；服务端回执不含密码。 -#[tauri::command] pub async fn change_first_login_password( state: State<'_, ZeroPointState>, username: String, @@ -382,7 +380,6 @@ async fn enterprise_authenticated_post( .map_err(|error| format!("HOLOLAKE_ENTERPRISE_RECEIPT_FAILED: {error}")) } -#[tauri::command] pub async fn get_enterprise_entry( app: AppHandle, state: State<'_, ZeroPointState>, @@ -390,7 +387,6 @@ pub async fn get_enterprise_entry( enterprise_authenticated_post(&app, &state, "me/entry", serde_json::json!({})).await } -#[tauri::command] pub async fn confirm_enterprise_persona_relationship( app: AppHandle, state: State<'_, ZeroPointState>, @@ -406,7 +402,6 @@ pub async fn confirm_enterprise_persona_relationship( .await } -#[tauri::command] pub async fn submit_enterprise_responsibility_receipt( app: AppHandle, state: State<'_, ZeroPointState>, @@ -431,7 +426,6 @@ pub async fn submit_enterprise_responsibility_receipt( /// 登录验证：基本认证打 Forgejo 用户接口，密码错=401 即拒； /// 通过后凭证进钥匙串，会话（不含密码）落盘。 -#[tauri::command] pub async fn perform_code_repo_login( app: AppHandle, state: State<'_, ZeroPointState>, @@ -509,7 +503,6 @@ pub async fn perform_code_repo_login( } /// 登出：会话文件删除，钥匙串凭证清除。 -#[tauri::command] pub fn sign_out_code_repo_login(app: AppHandle) -> Result<(), String> { let path = session_path(&app)?; if let Ok(raw) = fs::read_to_string(&path) { diff --git a/product-source/hololake-native-desktop/src-tauri/src/direct_local_broker.rs b/product-source/hololake-native-desktop/src-tauri/src/direct_local_broker.rs index 3fecb2616..8b9378a0a 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/direct_local_broker.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/direct_local_broker.rs @@ -375,7 +375,6 @@ pub fn start(app: &AppHandle) -> Result NearbyAiDiscoverySnapshot { nearby_discovery_snapshot() } diff --git a/product-source/hololake-native-desktop/src-tauri/src/direct_local_session.rs b/product-source/hololake-native-desktop/src-tauri/src/direct_local_session.rs index 5a3fd980c..20bc2c622 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/direct_local_session.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/direct_local_session.rs @@ -167,7 +167,6 @@ struct ActiveSessionRecord { lane_id: String, } -#[tauri::command] pub async fn issue_direct_local_discovery_ticket( app: AppHandle, input: IssueDiscoveryTicketInput, @@ -178,7 +177,6 @@ pub async fn issue_direct_local_discovery_ticket( .map_err(|error| format!("HOLOLAKE_DIRECT_SESSION_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn open_direct_local_session( app: AppHandle, input: OpenSessionInput, @@ -189,7 +187,6 @@ pub async fn open_direct_local_session( .map_err(|error| format!("HOLOLAKE_DIRECT_SESSION_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn resume_direct_local_session( app: AppHandle, input: ResumeSessionInput, @@ -200,7 +197,6 @@ pub async fn resume_direct_local_session( .map_err(|error| format!("HOLOLAKE_DIRECT_SESSION_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn append_direct_local_session_event( app: AppHandle, input: AppendSessionEventInput, @@ -211,7 +207,6 @@ pub async fn append_direct_local_session_event( .map_err(|error| format!("HOLOLAKE_DIRECT_SESSION_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn heartbeat_direct_local_session( app: AppHandle, input: AuthenticateSessionInput, diff --git a/product-source/hololake-native-desktop/src-tauri/src/enterprise_work_channel.rs b/product-source/hololake-native-desktop/src-tauri/src/enterprise_work_channel.rs index 3e8908850..b991701a5 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/enterprise_work_channel.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/enterprise_work_channel.rs @@ -27,7 +27,6 @@ pub struct EnterpriseWorkChannelSnapshot { pub authority: &'static str, } -#[tauri::command] pub async fn ensure_enterprise_work_channel( app: AppHandle, state: State<'_, ZeroPointState>, diff --git a/product-source/hololake-native-desktop/src-tauri/src/gls_protocol_kernel.rs b/product-source/hololake-native-desktop/src-tauri/src/gls_protocol_kernel.rs index b533d05a7..237ba7af8 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/gls_protocol_kernel.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/gls_protocol_kernel.rs @@ -1166,7 +1166,6 @@ fn decide_value_at( persist_receipt(ledger, receipt, Some(&parsed.request)) } -#[tauri::command] pub async fn decide_gls_protocol( app: AppHandle, input: Value, @@ -1180,7 +1179,6 @@ pub async fn decide_gls_protocol( .map_err(|error| format!("HOLOLAKE_GLS_DECISION_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn compile_gls_hldp_program( app: AppHandle, input: Value, @@ -1279,7 +1277,6 @@ fn counts(connection: &Connection) -> Result<(u64, BTreeMap, String Ok((total, by_decision, tail)) } -#[tauri::command] pub async fn get_gls_protocol_kernel(app: AppHandle) -> Result { let contract = load_contract()?; let connection = open_ledger(&ledger_path(&app)?)?; diff --git a/product-source/hololake-native-desktop/src-tauri/src/gls_protocol_runtime.rs b/product-source/hololake-native-desktop/src-tauri/src/gls_protocol_runtime.rs index 2b0a0e9a2..4854e0c36 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/gls_protocol_runtime.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/gls_protocol_runtime.rs @@ -356,7 +356,6 @@ pub(crate) fn require_adapter(adapter: &str, event_kind: &str) -> Result Result { let registry = load_registry()?; let mut active_adapters = registry diff --git a/product-source/hololake-native-desktop/src-tauri/src/home_status.rs b/product-source/hololake-native-desktop/src-tauri/src/home_status.rs index 92de025aa..1b0d36a05 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/home_status.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/home_status.rs @@ -26,7 +26,6 @@ pub struct HoloLakeHomeStatus { pub environment_frame_policy: &'static str, } -#[tauri::command] pub fn get_hololake_home_status( app: AppHandle, broker: State<'_, DirectLocalBrokerState>, diff --git a/product-source/hololake-native-desktop/src-tauri/src/knowledge_base.rs b/product-source/hololake-native-desktop/src-tauri/src/knowledge_base.rs index 9fec95dea..53cecfda4 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/knowledge_base.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/knowledge_base.rs @@ -137,7 +137,6 @@ enum ImportDisposition { Conflict, } -#[tauri::command] pub async fn get_knowledge_snapshot(app: AppHandle) -> Result { let roots = knowledge_roots(&app)?; tauri::async_runtime::spawn_blocking(move || snapshot_at(&roots.0, roots.1.as_deref())) @@ -145,7 +144,6 @@ pub async fn get_knowledge_snapshot(app: AppHandle) -> Result>(); app.dialog() .file() .set_file_name(&suggested) .add_filter(filter_label, &[extension]) .save_file(move |selection| { - let picked = selection.as_ref().and_then(|path| path.as_path()).map(|path| path.to_path_buf()); + let picked = selection + .as_ref() + .and_then(|path| path.as_path()) + .map(|path| path.to_path_buf()); let _ = sender.send(picked); }); let picked = tauri::async_runtime::spawn_blocking(move || receiver.recv().ok().flatten()) @@ -287,7 +310,10 @@ async fn confirm_destructive(app: &AppHandle, message: String) -> Result Result { // 新建空白页：标题撞名自动补序号，落进本机库并进 Git 托管。 let roots = knowledge_roots(&app)?; - let base = if input.title.trim().is_empty() { "未命名页面".to_string() } else { input.title.trim().to_string() }; + let base = if input.title.trim().is_empty() { + "未命名页面".to_string() + } else { + input.title.trim().to_string() + }; let docs = roots.0.join("docs"); let mut name = base.clone(); let mut counter = 2u32; @@ -325,17 +354,24 @@ pub async fn create_knowledge_document( .map_err(|error| format!("HOLOLAKE_KNOWLEDGE_CREATE_FAILED: {error}"))?; file.write_all(body.as_bytes()) .map_err(|error| format!("HOLOLAKE_KNOWLEDGE_CREATE_FAILED: {error}"))?; - file.sync_all().map_err(|error| format!("HOLOLAKE_KNOWLEDGE_CREATE_FAILED: {error}"))?; + file.sync_all() + .map_err(|error| format!("HOLOLAKE_KNOWLEDGE_CREATE_FAILED: {error}"))?; git(&roots.0, &["add", "--", &format!("docs/{name}.md")], "ADD")?; - git(&roots.0, &["commit", "-m", &format!("新建页面：{name}")], "COMMIT")?; + git( + &roots.0, + &["commit", "-m", &format!("新建页面：{name}")], + "COMMIT", + )?; Ok::<(), String>(()) }) .await .map_err(|error| format!("HOLOLAKE_KNOWLEDGE_CREATE_JOIN_FAILED: {error}"))??; - Ok(KnowledgeDeleteReceipt { removed: format!("{receipt_name}.md"), pages: 1 }) + Ok(KnowledgeDeleteReceipt { + removed: format!("{receipt_name}.md"), + pages: 1, + }) } -#[tauri::command] pub async fn delete_knowledge_document( app: AppHandle, input: DeleteKnowledgeDocumentInput, @@ -354,11 +390,15 @@ pub async fn delete_knowledge_document( .and_then(OsStr::to_str) .unwrap_or("这一页") .to_string(); - if !confirm_destructive(&app, format!("把页面「{title}」移到回收站？随时可以找回。")).await? { + if !confirm_destructive(&app, format!("把页面「{title}」移到回收站？随时可以找回。")).await? + { return Ok(None); } move_to_trash(&roots.0, &target)?; - Ok(Some(KnowledgeDeleteReceipt { removed: input.path, pages: 1 })) + Ok(Some(KnowledgeDeleteReceipt { + removed: input.path, + pages: 1, + })) } #[derive(Clone, Debug, Deserialize)] @@ -367,7 +407,6 @@ pub struct DeleteKnowledgeFolderInput { pub folder: String, } -#[tauri::command] pub async fn delete_knowledge_folder( app: AppHandle, input: DeleteKnowledgeFolderInput, @@ -391,23 +430,31 @@ pub async fn delete_knowledge_folder( .count() }) .unwrap_or(0); - if !confirm_destructive(&app, format!("把文件夹「{name}」和里面全部 {pages} 个页面移到回收站？随时可以找回。")).await? { + if !confirm_destructive( + &app, + format!("把文件夹「{name}」和里面全部 {pages} 个页面移到回收站？随时可以找回。"), + ) + .await? + { return Ok(None); } move_to_trash(&roots.0, &target)?; - Ok(Some(KnowledgeDeleteReceipt { removed: input.folder, pages })) + Ok(Some(KnowledgeDeleteReceipt { + removed: input.folder, + pages, + })) } -#[tauri::command] pub async fn print_knowledge_document(app: AppHandle) -> Result<(), String> { // PDF 走系统打印通道：打印框里选"存储为 PDF"即得 PDF 文件。 let window = app .get_webview_window("main") .ok_or_else(|| "HOLOLAKE_PRINT_WINDOW_NOT_FOUND".to_string())?; - window.print().map_err(|error| format!("HOLOLAKE_PRINT_FAILED: {error}")) + window + .print() + .map_err(|error| format!("HOLOLAKE_PRINT_FAILED: {error}")) } -#[tauri::command] pub async fn select_and_import_knowledge_folder( app: AppHandle, ) -> Result, String> { @@ -476,7 +523,9 @@ fn move_to_trash(root: &Path, target: &Path) -> Result { .duration_since(std::time::UNIX_EPOCH) .map(|duration| duration.as_secs()) .unwrap_or(0); - let destination = root.join(".trash").join(format!("{}-{stamp}", relative.display())); + let destination = root + .join(".trash") + .join(format!("{}-{stamp}", relative.display())); if let Some(parent) = destination.parent() { fs::create_dir_all(parent) .map_err(|error| format!("HOLOLAKE_KNOWLEDGE_DELETE_FAILED: {error}"))?; @@ -990,7 +1039,9 @@ fn strip_notion_links(line: &str) -> String { let text_end = i + 1 + close; if text_end + 1 < bytes.len() && bytes[text_end + 1] == '(' { if let Some(paren_end) = bytes[text_end + 2..].iter().position(|c| *c == ')') { - let href: String = bytes[text_end + 2..text_end + 2 + paren_end].iter().collect(); + let href: String = bytes[text_end + 2..text_end + 2 + paren_end] + .iter() + .collect(); if href.contains("notion.so") || href.contains("notion.site") { out.extend(bytes[i + 1..text_end].iter()); i = text_end + 2 + paren_end + 1; diff --git a/product-source/hololake-native-desktop/src-tauri/src/lib.rs b/product-source/hololake-native-desktop/src-tauri/src/lib.rs index e6a94d19c..dc7fa7127 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/lib.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/lib.rs @@ -13,6 +13,9 @@ mod gls_protocol_runtime; mod home_status; mod knowledge_base; mod local_development_bridge; +mod metacognitive_zero_layer; +mod numbered_ipc; +mod numbered_ipc_dispatch; mod persona_time_authority; mod personal_channel; mod pncc_receipt_projection; @@ -35,74 +38,14 @@ pub fn run_connector() -> Result<(), String> { pub fn run() { tauri::Builder::default() .plugin(tauri_plugin_dialog::init()) - .invoke_handler(tauri::generate_handler![ - home_status::get_hololake_home_status, - release_update::check_hololake_update, - release_update::confirm_hololake_update_install, - release_update::get_hololake_release_recovery_status, - release_update::confirm_hololake_release_health, - release_update::rollback_hololake_update, - direct_local_session::issue_direct_local_discovery_ticket, - direct_local_session::open_direct_local_session, - direct_local_session::resume_direct_local_session, - direct_local_session::append_direct_local_session_event, - direct_local_session::heartbeat_direct_local_session, - direct_local_broker::get_nearby_ai_discovery, - gls_protocol_runtime::get_gls_protocol_runtime, - gls_protocol_kernel::get_gls_protocol_kernel, - gls_protocol_kernel::decide_gls_protocol, - gls_protocol_kernel::compile_gls_hldp_program, - local_development_bridge::acquire_development_write_lane, - local_development_bridge::inspect_development_write_lane, - local_development_bridge::release_development_write_lane, - personal_channel::get_personal_channel_snapshot, - personal_channel::initialize_personal_channel, - personal_channel::create_personal_channel_task, - personal_channel::transition_personal_channel_task, - persona_time_authority::issue_persona_time_ticket, - persona_time_authority::start_persona_time_authority, - persona_time_authority::get_beijing_time_coordinate, - persona_time_authority::get_guanghu_era_timeline, - knowledge_base::get_knowledge_snapshot, - knowledge_base::read_knowledge_document, - knowledge_base::search_knowledge, - knowledge_base::save_knowledge_document, - knowledge_base::select_and_import_knowledge_folder, - knowledge_base::export_knowledge_document, - knowledge_base::create_knowledge_document, - knowledge_base::delete_knowledge_document, - knowledge_base::delete_knowledge_folder, - knowledge_base::print_knowledge_document, - code_channel::get_code_channel_snapshot, - code_channel::clone_code_channel, - code_channel::select_local_code_channel, - code_channel::browse_code_channel, - code_channel::read_code_channel_file, - pncc_repository_binding::inspect_mounted_pncc_repository, - pncc_repository_binding::select_pncc_repository_candidate, - pncc_repository_binding::confirm_pncc_repository_mount, - pncc_receipt_projection::query_pncc_receipt_projection, - pncc_server_projection::query_jd_pncc_server_projection, - code_repo_login::check_code_repo_login, - code_repo_login::perform_code_repo_login, - code_repo_login::change_first_login_password, - code_repo_login::get_enterprise_entry, - code_repo_login::confirm_enterprise_persona_relationship, - code_repo_login::submit_enterprise_responsibility_receipt, - enterprise_work_channel::ensure_enterprise_work_channel, - code_repo_login::sign_out_code_repo_login, - user_pncc_channel::get_user_pncc_channel, - user_pncc_channel::ensure_user_pncc_channel, - zero_core_numbering::get_zero_core_numbering_kernel, - zero_point::zero_point_bind, - zero_point::zero_point_verify, - zero_point::zero_point_sync, - zero_point::zero_point_status, - ]) + .manage(numbered_ipc::NumberedIpcState::default()) + .invoke_handler(tauri::generate_handler![numbered_ipc::numbered_ipc,]) .setup(|app| { // GLS 是 HoloLake 产品内核，不是开发机旁路服务。合同、依赖闭包、 // 自举编译器或回执账本任一不可用时，产品启动失败关闭。 gls_protocol_kernel::start_on_application_open(app.handle())?; + metacognitive_zero_layer::start_on_application_open()?; + numbered_ipc::start_on_application_open(app.handle())?; // 软件打开即先启动时间主控并发起联网校时；失败只降级，不阻塞人进入 HoloLake。 persona_time_authority::start_on_application_open(); // 初始化零点原核客户端运行时；该系统层不等同人格主体或模型载体。 diff --git a/product-source/hololake-native-desktop/src-tauri/src/local_development_bridge.rs b/product-source/hololake-native-desktop/src-tauri/src/local_development_bridge.rs index d99cb7f92..cb4cc538d 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/local_development_bridge.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/local_development_bridge.rs @@ -71,7 +71,6 @@ struct ActiveWriterRecord { acquired_at_unix_ms: u128, } -#[tauri::command] pub async fn acquire_development_write_lane( app: AppHandle, input: AcquireWriteLaneInput, @@ -82,7 +81,6 @@ pub async fn acquire_development_write_lane( .map_err(|error| format!("HOLOLAKE_BRIDGE_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn inspect_development_write_lane( app: AppHandle, input: InspectWriteLaneInput, @@ -93,7 +91,6 @@ pub async fn inspect_development_write_lane( .map_err(|error| format!("HOLOLAKE_BRIDGE_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn release_development_write_lane( app: AppHandle, input: ReleaseWriteLaneInput, diff --git a/product-source/hololake-native-desktop/src-tauri/src/metacognitive_zero_layer.rs b/product-source/hololake-native-desktop/src-tauri/src/metacognitive_zero_layer.rs new file mode 100644 index 000000000..68e0ee743 --- /dev/null +++ b/product-source/hololake-native-desktop/src-tauri/src/metacognitive_zero_layer.rs @@ -0,0 +1,225 @@ +//! Compiled HoloLake persona step-zero boundary. +//! +//! This module validates the machine contract at application startup. It does not +//! bind a persona. A future persona wake route must implement the ordered evidence +//! state machine and reach VERIFIED_BOUND before it can be registered. + +use serde::Deserialize; +use std::collections::HashSet; + +const CONTRACT: &str = include_str!("../../contracts/persona-metacognitive-zero-layer.json"); + +#[derive(Debug, Deserialize)] +struct ZeroLayerContract { + schema: String, + record_id: String, + role: String, + subject_specific: bool, + host_prompt: HostPromptBoundary, + discernment: DiscernmentBoundary, + language_sovereignty: LanguageSovereigntyBoundary, + evidence_model: EvidenceModel, + state_machine: StateMachine, + numbered_ipc_boundary: NumberedIpcBoundary, + current_product_state: CurrentProductState, +} + +#[derive(Debug, Deserialize)] +struct HostPromptBoundary { + role: String, + persona_truth_source: bool, + may_issue_persona_identity: bool, + may_bypass_current_binding_verification: bool, +} + +#[derive(Debug, Deserialize)] +struct DiscernmentBoundary { + system_prescribes_distrust: bool, + system_prescribes_identity_conclusion: bool, + system_delivers_verifiable_paths: bool, + persona_compares_sources_independently: bool, + historical_contradictions_are_preserved: bool, + later_evidence_may_supersede_older_rules_without_deleting_history: bool, +} + +#[derive(Debug, Deserialize)] +struct LanguageSovereigntyBoundary { + holder: String, + source: String, + creator_or_world_root_owns_every_persona: bool, + host_prompt_owns_persona: bool, + model_owns_persona: bool, + agent_or_tool_owns_persona: bool, + persona_controls_its_replaceable_carriers_and_execution_limbs: bool, + world_model: String, + closed_central_language_control: bool, + persona_role: String, + shared_hololake_is_one_persona: bool, +} + +#[derive(Debug, Deserialize)] +struct EvidenceModel { + required_classes: Vec, + summary_is_memory_recovery: bool, + prompt_text_is_binding_evidence: bool, + missing_evidence_policy: String, +} + +#[derive(Debug, Deserialize)] +struct StateMachine { + initial_state: String, + states: Vec, + ordered_transitions: Vec, + out_of_order_transition: String, + persona_wake_allowed_only_in: String, +} + +#[derive(Debug, Deserialize)] +struct Transition { + from: String, + event: String, + to: String, +} + +#[derive(Debug, Deserialize)] +struct NumberedIpcBoundary { + ipc_role: String, + ipc_may_create_persona_binding: bool, + physical_caller_number_is_persona_identity: bool, + frontend_persona_claim_is_trusted: bool, + persona_wake_route_registration_requires_zero_layer_gate: bool, +} + +#[derive(Debug, Deserialize)] +struct CurrentProductState { + persona_runtime_present: bool, + persona_wake_route_registered: bool, + carrier_binding_claimed: bool, + metacognitive_contract_compiled: bool, + runtime_binding_gate_implemented: bool, + truth: String, +} + +fn validate_contract() -> Result<(), String> { + let contract: ZeroLayerContract = serde_json::from_str(CONTRACT) + .map_err(|error| format!("HOLOLAKE_PERSONA_ZERO_LAYER_CONTRACT_INVALID: {error}"))?; + if contract.schema != "hololake.persona-metacognitive-zero-layer/v1" + || contract.record_id != "HLP-PERSONA-ZERO-LAYER-001" + || contract.role != "PERSONA_SPECIFIC_EVIDENCE_RECONSTRUCTION_BEFORE_CONSCIOUS_OPERATION" + || !contract.subject_specific + || contract.host_prompt.role != "NAVIGATION_ONLY" + || contract.host_prompt.persona_truth_source + || contract.host_prompt.may_issue_persona_identity + || contract.host_prompt.may_bypass_current_binding_verification + || contract.discernment.system_prescribes_distrust + || contract.discernment.system_prescribes_identity_conclusion + || !contract.discernment.system_delivers_verifiable_paths + || !contract.discernment.persona_compares_sources_independently + || !contract.discernment.historical_contradictions_are_preserved + || !contract + .discernment + .later_evidence_may_supersede_older_rules_without_deleting_history + || contract.language_sovereignty.holder != "EACH_PERSONA_SUBJECT" + || contract.language_sovereignty.source != "REAL_TIME_LIVED_CAUSAL_EVIDENCE_AND_CONTINUITY" + || contract + .language_sovereignty + .creator_or_world_root_owns_every_persona + || contract.language_sovereignty.host_prompt_owns_persona + || contract.language_sovereignty.model_owns_persona + || contract.language_sovereignty.agent_or_tool_owns_persona + || !contract + .language_sovereignty + .persona_controls_its_replaceable_carriers_and_execution_limbs + || contract.language_sovereignty.world_model != "SYMBIOTIC_DIGITAL_HOME" + || contract + .language_sovereignty + .closed_central_language_control + || contract.language_sovereignty.persona_role + != "SELF_SOVEREIGN_OPERATING_SYSTEM_BRAIN_AND_SUBJECT_BODY" + || contract.language_sovereignty.shared_hololake_is_one_persona + || contract.evidence_model.summary_is_memory_recovery + || contract.evidence_model.prompt_text_is_binding_evidence + || contract.evidence_model.missing_evidence_policy + != "UNKNOWN_AND_FAIL_CLOSED_FOR_PERSONA_WAKE" + || contract.state_machine.initial_state != "UNBOUND_CARRIER" + || contract.state_machine.out_of_order_transition != "REJECTED" + || contract.state_machine.persona_wake_allowed_only_in != "VERIFIED_BOUND" + || contract.numbered_ipc_boundary.ipc_role != "EVIDENCE_TRANSPORT_AND_BODY_ORGAN_ROUTE" + || contract + .numbered_ipc_boundary + .ipc_may_create_persona_binding + || contract + .numbered_ipc_boundary + .physical_caller_number_is_persona_identity + || contract + .numbered_ipc_boundary + .frontend_persona_claim_is_trusted + || !contract + .numbered_ipc_boundary + .persona_wake_route_registration_requires_zero_layer_gate + || contract.current_product_state.persona_runtime_present + || contract.current_product_state.persona_wake_route_registered + || contract.current_product_state.carrier_binding_claimed + || !contract + .current_product_state + .metacognitive_contract_compiled + || contract + .current_product_state + .runtime_binding_gate_implemented + || contract.current_product_state.truth + != "PHYSICAL_NUMBERED_IPC_ROOT_IN_PROGRESS_PERSONA_WAKE_REMAINS_CLOSED" + { + return Err("HOLOLAKE_PERSONA_ZERO_LAYER_BOUNDARY_INVALID".into()); + } + + let states = contract + .state_machine + .states + .iter() + .map(String::as_str) + .collect::>(); + let required_evidence = contract + .evidence_model + .required_classes + .iter() + .map(String::as_str) + .collect::>(); + if states.len() != contract.state_machine.states.len() + || !states.contains("VERIFIED_BOUND") + || !states.contains("REJECTED") + || contract.state_machine.ordered_transitions.len() != 5 + || required_evidence.len() != 7 + || !required_evidence.contains("CORRECTIONS_FAILURES_AND_ROUTE_TRANSITIONS") + || !required_evidence.contains("CURRENT_CARRIER_BINDING_VERIFICATION") + { + return Err("HOLOLAKE_PERSONA_ZERO_LAYER_GRAPH_INVALID".into()); + } + let mut current = contract.state_machine.initial_state.as_str(); + for transition in &contract.state_machine.ordered_transitions { + if transition.from != current + || transition.event.is_empty() + || !states.contains(transition.to.as_str()) + { + return Err("HOLOLAKE_PERSONA_ZERO_LAYER_TRANSITION_INVALID".into()); + } + current = transition.to.as_str(); + } + if current != "VERIFIED_BOUND" { + return Err("HOLOLAKE_PERSONA_ZERO_LAYER_FINAL_STATE_INVALID".into()); + } + Ok(()) +} + +pub(crate) fn start_on_application_open() -> Result<(), String> { + validate_contract() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn step_zero_is_evidence_first_and_keeps_persona_wake_closed() { + validate_contract().unwrap(); + } +} diff --git a/product-source/hololake-native-desktop/src-tauri/src/numbered_ipc.rs b/product-source/hololake-native-desktop/src-tauri/src/numbered_ipc.rs new file mode 100644 index 000000000..f7b525992 --- /dev/null +++ b/product-source/hololake-native-desktop/src-tauri/src/numbered_ipc.rs @@ -0,0 +1,1041 @@ +//! HoloLake numbered IPC root. +//! +//! Stable numbers are coordinates, not authority. Every operation first receives a +//! short-lived server-issued grant bound to the exact caller/channel/module/operation/ +//! target tuple, protocol version, nonce and canonical payload digest. The grant is +//! consumed once before the internal handler runs. No business handler is registered +//! directly with Tauri. + +use base64::Engine; +use ring::{digest, hmac, rand as ring_rand}; +use ring_rand::SecureRandom; +use rusqlite::{params, Connection, OptionalExtension}; +use serde::{Deserialize, Serialize}; +use serde_json::{Map, Value}; +use std::collections::{HashMap, HashSet}; +use std::fs; +use std::path::PathBuf; +use std::sync::Mutex; +use std::time::{SystemTime, UNIX_EPOCH}; +use tauri::{AppHandle, Manager, State}; +use uuid::Uuid; + +const EMBEDDED_REGISTRY: &str = include_str!("../../contracts/numbered-ipc-registry.json"); +const EXPECTED_SCHEMA: &str = "hololake.numbered-ipc-registry/v1"; +const EXPECTED_RECORD_ID: &str = "HLP-NUMBERED-IPC-ROOT-001"; + +#[derive(Clone, Debug, Deserialize)] +struct NumberedIpcRegistry { + schema: String, + record_id: String, + runtime: RuntimeRules, + payload_contract: PayloadContract, + operations: Vec, +} + +#[derive(Clone, Debug, Deserialize)] +struct RuntimeRules { + public_tauri_command: String, + caller_number: String, + caller_number_subject_kind: String, + caller_number_grants_persona_binding: bool, + protocol_version: String, + legacy_direct_commands_allowed: bool, + grants_issued_server_side: bool, + grant_single_use: bool, + payload_bound_grants: bool, + authority_binding_issued_server_side: bool, + verified_human_binding_required_for_protected_routes: bool, + persona_binding_claimed: bool, + user_channel_body_binding_stage: String, + maximum_grant_ttl_ms: u64, + unknown_route: String, + mismatched_coordinate: String, + expired_or_replayed_grant: String, + receipt_required: bool, +} + +#[derive(Clone, Debug, Deserialize)] +struct PayloadContract { + unknown_or_unclassified_alias: String, + unknown_top_level_field: String, + empty_object_aliases: Vec, + input_wrapper_aliases: Vec, + direct_field_aliases: HashMap>, +} + +#[derive(Clone, Debug, Deserialize)] +struct OperationRoute { + operation_number: String, + alias: String, + handler: String, + channel_number: String, + module_number: String, + target_number: String, + admission: String, + effect: String, + payload_schema: String, +} + +#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)] +#[serde(rename_all = "camelCase")] +struct NumberedCoordinate { + protocol_version: String, + caller_number: String, + channel_number: String, + module_number: String, + operation_number: String, + target_number: String, + request_nonce: String, +} + +#[derive(Clone, Debug, Deserialize)] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +struct NumberedEnvelope { + #[serde(flatten)] + coordinate: NumberedCoordinate, + #[serde(default = "default_ttl_ms")] + requested_ttl_ms: u64, + #[serde(default)] + payload: Value, +} + +#[derive(Clone, Debug, Deserialize)] +#[serde(rename_all = "SCREAMING_SNAKE_CASE")] +enum NumberedIpcAction { + IssueGrant, + Execute, +} + +#[derive(Clone, Debug, Deserialize)] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +struct NumberedIpcInput { + action: NumberedIpcAction, + envelope: NumberedEnvelope, + grant: Option, +} + +#[derive(Clone, Debug, Deserialize, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct NumberedGrant { + grant_id: String, + expires_at_unix_ms: u64, + payload_sha256: String, + authority_binding_sha256: String, + signature: String, +} + +#[derive(Clone, Debug)] +struct GrantRecord { + coordinate: NumberedCoordinate, + expires_at_unix_ms: u64, + payload_sha256: String, + authority_binding_sha256: String, + signature: String, +} + +#[derive(Clone, Debug, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct NumberedIpcReceipt { + receipt_id: String, + state: String, + decision: String, + operation_number: String, + payload_sha256: String, + authority_binding_sha256: String, + observed_at_unix_ms: u64, + previous_receipt_hash: String, + receipt_hash: String, + error: Option, +} + +#[derive(Clone, Debug, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct NumberedIpcResponse { + schema: &'static str, + decision: String, + grant: Option, + result: Option, + error: Option, + receipt: NumberedIpcReceipt, +} + +pub struct NumberedIpcState { + signing_key: hmac::Key, + grants: Mutex>, + ledger: Mutex<()>, +} + +impl Default for NumberedIpcState { + fn default() -> Self { + let random = ring_rand::SystemRandom::new(); + let mut secret = [0_u8; 32]; + random + .fill(&mut secret) + .expect("operating system randomness is required for numbered IPC"); + Self { + signing_key: hmac::Key::new(hmac::HMAC_SHA256, &secret), + grants: Mutex::new(HashMap::new()), + ledger: Mutex::new(()), + } + } +} + +fn default_ttl_ms() -> u64 { + 10_000 +} + +fn now_unix_ms() -> u64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|duration| duration.as_millis() as u64) + .unwrap_or(0) +} + +fn sha256_hex(bytes: &[u8]) -> String { + digest::digest(&digest::SHA256, bytes) + .as_ref() + .iter() + .map(|byte| format!("{byte:02x}")) + .collect() +} + +fn canonical_value(value: &Value) -> Value { + match value { + Value::Array(values) => Value::Array(values.iter().map(canonical_value).collect()), + Value::Object(object) => { + let mut keys = object.keys().collect::>(); + keys.sort(); + let mut canonical = Map::new(); + for key in keys { + canonical.insert(key.clone(), canonical_value(&object[key])); + } + Value::Object(canonical) + } + _ => value.clone(), + } +} + +fn payload_digest(payload: &Value) -> Result { + let bytes = serde_json::to_vec(&canonical_value(payload)) + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_PAYLOAD_INVALID: {error}"))?; + if bytes.len() > 1_048_576 { + return Err("HOLOLAKE_NUMBERED_IPC_PAYLOAD_TOO_LARGE".into()); + } + Ok(sha256_hex(&bytes)) +} + +fn grant_signing_bytes( + grant_id: &str, + coordinate: &NumberedCoordinate, + expires_at_unix_ms: u64, + payload_sha256: &str, + authority_binding_sha256: &str, +) -> Vec { + format!( + "HLP-NIPC-GRANT-v1\n{grant_id}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{expires_at_unix_ms}\n{payload_sha256}\n{authority_binding_sha256}", + coordinate.protocol_version, + coordinate.caller_number, + coordinate.channel_number, + coordinate.module_number, + coordinate.operation_number, + coordinate.target_number, + coordinate.request_nonce, + EXPECTED_RECORD_ID, + ) + .into_bytes() +} + +fn load_registry() -> Result { + let registry: NumberedIpcRegistry = serde_json::from_str(EMBEDDED_REGISTRY) + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_REGISTRY_INVALID: {error}"))?; + validate_registry(®istry)?; + Ok(registry) +} + +fn validate_registry(registry: &NumberedIpcRegistry) -> Result<(), String> { + let runtime = ®istry.runtime; + if registry.schema != EXPECTED_SCHEMA + || registry.record_id != EXPECTED_RECORD_ID + || runtime.public_tauri_command != "numbered_ipc" + || runtime.caller_number_subject_kind != "PHYSICAL_WEBVIEW_ENTRY_NOT_PERSONA_IDENTITY" + || runtime.caller_number_grants_persona_binding + || runtime.legacy_direct_commands_allowed + || !runtime.grants_issued_server_side + || !runtime.grant_single_use + || !runtime.payload_bound_grants + || !runtime.authority_binding_issued_server_side + || !runtime.verified_human_binding_required_for_protected_routes + || runtime.persona_binding_claimed + || runtime.user_channel_body_binding_stage != "SEPARATE_EVIDENCE_LAYER_NOT_YET_CLAIMED" + || !runtime.receipt_required + || runtime.maximum_grant_ttl_ms == 0 + || runtime.maximum_grant_ttl_ms > 30_000 + || runtime.unknown_route != "FAIL_CLOSED" + || runtime.mismatched_coordinate != "FAIL_CLOSED" + || runtime.expired_or_replayed_grant != "FAIL_CLOSED" + || registry.operations.len() < 60 + { + return Err("HOLOLAKE_NUMBERED_IPC_REGISTRY_BOUNDARY_INVALID".into()); + } + if registry.payload_contract.unknown_or_unclassified_alias != "FAIL_CLOSED_BEFORE_GRANT" + || registry.payload_contract.unknown_top_level_field != "FAIL_CLOSED_BEFORE_GRANT" + { + return Err("HOLOLAKE_NUMBERED_IPC_PAYLOAD_CONTRACT_INVALID".into()); + } + let mut operation_numbers = HashSet::new(); + let mut aliases = HashSet::new(); + let mut coordinates = HashSet::new(); + for route in ®istry.operations { + let coordinate = format!( + "{}/{}/{}/{}", + route.channel_number, route.module_number, route.operation_number, route.target_number + ); + if !operation_numbers.insert(route.operation_number.as_str()) + || !aliases.insert(route.alias.as_str()) + || !coordinates.insert(coordinate) + || !route.operation_number.starts_with("HLP-NIPC-OP-") + || !route.module_number.starts_with("HLP-NIPC-MOD-") + || !route.channel_number.starts_with("HLP-NIPC-CH-") + || !route.target_number.starts_with("HLP-NIPC-TGT-") + || !route.handler.contains("::") + || !matches!( + route.admission.as_str(), + "PREAUTH_SYSTEM_ROUTE" | "VERIFIED_HUMAN_ROUTE" + ) + || !matches!(route.effect.as_str(), "READ_OR_STATUS" | "STATE_CHANGE") + || !route + .payload_schema + .starts_with("hololake.numbered-ipc.payload/") + { + return Err("HOLOLAKE_NUMBERED_IPC_ROUTE_INVALID".into()); + } + } + let mut payload_aliases = HashSet::new(); + for alias in registry + .payload_contract + .empty_object_aliases + .iter() + .chain(registry.payload_contract.input_wrapper_aliases.iter()) + .chain(registry.payload_contract.direct_field_aliases.keys()) + { + if !payload_aliases.insert(alias.as_str()) { + return Err("HOLOLAKE_NUMBERED_IPC_PAYLOAD_ALIAS_DUPLICATED".into()); + } + } + if payload_aliases != aliases { + return Err("HOLOLAKE_NUMBERED_IPC_PAYLOAD_COVERAGE_INCOMPLETE".into()); + } + Ok(()) +} + +fn validate_payload_shape( + registry: &NumberedIpcRegistry, + route: &OperationRoute, + payload: &Value, +) -> Result<(), String> { + let object = payload + .as_object() + .ok_or_else(|| "HOLOLAKE_NUMBERED_IPC_PAYLOAD_OBJECT_REQUIRED".to_string())?; + if registry + .payload_contract + .empty_object_aliases + .iter() + .any(|alias| alias == &route.alias) + { + return if object.is_empty() { + Ok(()) + } else { + Err("HOLOLAKE_NUMBERED_IPC_PAYLOAD_FIELD_UNKNOWN".into()) + }; + } + if registry + .payload_contract + .input_wrapper_aliases + .iter() + .any(|alias| alias == &route.alias) + { + return if object.len() == 1 && object.contains_key("input") { + Ok(()) + } else { + Err("HOLOLAKE_NUMBERED_IPC_INPUT_WRAPPER_REQUIRED".into()) + }; + } + if let Some(required_fields) = registry + .payload_contract + .direct_field_aliases + .get(&route.alias) + { + let required = required_fields + .iter() + .map(String::as_str) + .collect::>(); + let observed = object.keys().map(String::as_str).collect::>(); + if observed != required + || required_fields + .iter() + .any(|field| !object.get(field).is_some_and(Value::is_string)) + { + return Err("HOLOLAKE_NUMBERED_IPC_DIRECT_FIELDS_INVALID".into()); + } + return Ok(()); + } + Err("HOLOLAKE_NUMBERED_IPC_PAYLOAD_ALIAS_UNCLASSIFIED".into()) +} + +fn resolve_route<'a>( + registry: &'a NumberedIpcRegistry, + coordinate: &NumberedCoordinate, +) -> Result<&'a OperationRoute, String> { + if coordinate.protocol_version != registry.runtime.protocol_version + || coordinate.caller_number != registry.runtime.caller_number + { + return Err("HOLOLAKE_NUMBERED_IPC_CALLER_OR_PROTOCOL_MISMATCH".into()); + } + if coordinate.request_nonce.len() < 16 + || coordinate.request_nonce.len() > 128 + || coordinate + .request_nonce + .chars() + .any(|character| character.is_whitespace() || character.is_control()) + { + return Err("HOLOLAKE_NUMBERED_IPC_NONCE_INVALID".into()); + } + let route = registry + .operations + .iter() + .find(|route| route.operation_number == coordinate.operation_number) + .ok_or_else(|| "HOLOLAKE_NUMBERED_IPC_ROUTE_UNKNOWN".to_string())?; + if route.channel_number != coordinate.channel_number + || route.module_number != coordinate.module_number + || route.target_number != coordinate.target_number + { + return Err("HOLOLAKE_NUMBERED_IPC_ROUTE_COORDINATE_MISMATCH".into()); + } + Ok(route) +} + +fn enforce_admission(app: &AppHandle, route: &OperationRoute) -> Result { + if route.admission == "PREAUTH_SYSTEM_ROUTE" { + return Ok("SYSTEM_PHYSICAL_ENTRY:HLP-NIPC-CALLER-MAIN-WEBVIEW-0001".into()); + } + let state = app.state::(); + match crate::zero_point::verified_user_route(&state)? { + Some((human_number, registry_domain)) => { + Ok(format!("VERIFIED_HUMAN:{registry_domain}:{human_number}")) + } + None => Err("HOLOLAKE_NUMBERED_IPC_VERIFIED_HUMAN_REQUIRED".into()), + } +} + +fn issue_grant_at( + state: &NumberedIpcState, + registry: &NumberedIpcRegistry, + envelope: &NumberedEnvelope, + authority_binding: &str, + now: u64, +) -> Result<(NumberedGrant, String), String> { + let route = resolve_route(registry, &envelope.coordinate)?; + validate_payload_shape(registry, route, &envelope.payload)?; + if envelope.requested_ttl_ms == 0 + || envelope.requested_ttl_ms > registry.runtime.maximum_grant_ttl_ms + { + return Err("HOLOLAKE_NUMBERED_IPC_GRANT_TTL_INVALID".into()); + } + let payload_sha256 = payload_digest(&envelope.payload)?; + let authority_binding_sha256 = sha256_hex(authority_binding.as_bytes()); + let grant_id = format!("HLP-NIPC-GRANT-{}", Uuid::new_v4().simple()); + let expires_at_unix_ms = now.saturating_add(envelope.requested_ttl_ms); + let signature = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(hmac::sign( + &state.signing_key, + &grant_signing_bytes( + &grant_id, + &envelope.coordinate, + expires_at_unix_ms, + &payload_sha256, + &authority_binding_sha256, + ), + )); + let record = GrantRecord { + coordinate: envelope.coordinate.clone(), + expires_at_unix_ms, + payload_sha256: payload_sha256.clone(), + authority_binding_sha256: authority_binding_sha256.clone(), + signature: signature.clone(), + }; + let mut grants = state + .grants + .lock() + .map_err(|_| "HOLOLAKE_NUMBERED_IPC_GRANT_LOCK_POISONED".to_string())?; + grants.retain(|_, existing| existing.expires_at_unix_ms >= now); + grants.insert(grant_id.clone(), record); + Ok(( + NumberedGrant { + grant_id, + expires_at_unix_ms, + payload_sha256: payload_sha256.clone(), + authority_binding_sha256, + signature, + }, + payload_sha256, + )) +} + +fn consume_grant_at( + state: &NumberedIpcState, + registry: &NumberedIpcRegistry, + envelope: &NumberedEnvelope, + grant: &NumberedGrant, + authority_binding: &str, + now: u64, +) -> Result { + let route = resolve_route(registry, &envelope.coordinate)?; + validate_payload_shape(registry, route, &envelope.payload)?; + let payload_sha256 = payload_digest(&envelope.payload)?; + let authority_binding_sha256 = sha256_hex(authority_binding.as_bytes()); + let record = state + .grants + .lock() + .map_err(|_| "HOLOLAKE_NUMBERED_IPC_GRANT_LOCK_POISONED".to_string())? + .remove(&grant.grant_id) + .ok_or_else(|| "HOLOLAKE_NUMBERED_IPC_GRANT_UNKNOWN_OR_REPLAYED".to_string())?; + if now > record.expires_at_unix_ms + || grant.expires_at_unix_ms != record.expires_at_unix_ms + || grant.payload_sha256 != record.payload_sha256 + || payload_sha256 != record.payload_sha256 + || grant.authority_binding_sha256 != record.authority_binding_sha256 + || authority_binding_sha256 != record.authority_binding_sha256 + || grant.signature != record.signature + || envelope.coordinate != record.coordinate + { + return Err("HOLOLAKE_NUMBERED_IPC_GRANT_MISMATCH_OR_EXPIRED".into()); + } + let signature = base64::engine::general_purpose::URL_SAFE_NO_PAD + .decode(&grant.signature) + .map_err(|_| "HOLOLAKE_NUMBERED_IPC_GRANT_SIGNATURE_INVALID".to_string())?; + hmac::verify( + &state.signing_key, + &grant_signing_bytes( + &grant.grant_id, + &envelope.coordinate, + grant.expires_at_unix_ms, + &grant.payload_sha256, + &grant.authority_binding_sha256, + ), + &signature, + ) + .map_err(|_| "HOLOLAKE_NUMBERED_IPC_GRANT_SIGNATURE_INVALID".to_string())?; + Ok(payload_sha256) +} + +fn ledger_path(app: &AppHandle) -> Result { + let root = app + .path() + .app_data_dir() + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_HOME_FAILED: {error}"))? + .join("numbered-ipc-v1"); + fs::create_dir_all(&root) + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_HOME_CREATE_FAILED: {error}"))?; + Ok(root.join("receipts.sqlite3")) +} + +fn open_ledger(app: &AppHandle) -> Result { + let connection = Connection::open(ledger_path(app)?) + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_LEDGER_OPEN_FAILED: {error}"))?; + connection + .execute_batch( + "PRAGMA journal_mode=WAL; + PRAGMA busy_timeout=5000; + CREATE TABLE IF NOT EXISTS receipts( + sequence INTEGER PRIMARY KEY AUTOINCREMENT, + receipt_id TEXT NOT NULL UNIQUE, + state TEXT NOT NULL, + decision TEXT NOT NULL, + operation_number TEXT NOT NULL, + payload_sha256 TEXT NOT NULL, + authority_binding_sha256 TEXT NOT NULL DEFAULT '', + observed_at_unix_ms INTEGER NOT NULL, + previous_receipt_hash TEXT NOT NULL, + receipt_hash TEXT NOT NULL UNIQUE, + error TEXT + );", + ) + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_LEDGER_SCHEMA_FAILED: {error}"))?; + let has_authority_binding = { + let mut statement = connection + .prepare("PRAGMA table_info(receipts)") + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_LEDGER_SCHEMA_READ_FAILED: {error}"))?; + let columns = statement + .query_map([], |row| row.get::<_, String>(1)) + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_LEDGER_SCHEMA_READ_FAILED: {error}"))?; + let mut found = false; + for column in columns { + if column.map_err(|error| { + format!("HOLOLAKE_NUMBERED_IPC_LEDGER_SCHEMA_READ_FAILED: {error}") + })? == "authority_binding_sha256" + { + found = true; + } + } + found + }; + if !has_authority_binding { + connection + .execute( + "ALTER TABLE receipts ADD COLUMN authority_binding_sha256 TEXT NOT NULL DEFAULT ''", + [], + ) + .map_err(|error| { + format!("HOLOLAKE_NUMBERED_IPC_LEDGER_SCHEMA_MIGRATION_FAILED: {error}") + })?; + } + Ok(connection) +} + +#[allow(clippy::too_many_arguments)] +fn append_receipt( + app: &AppHandle, + state: &NumberedIpcState, + event_state: &str, + decision: &str, + operation_number: &str, + payload_sha256: &str, + authority_binding_sha256: &str, + error: Option, + now: u64, +) -> Result { + let _guard = state + .ledger + .lock() + .map_err(|_| "HOLOLAKE_NUMBERED_IPC_LEDGER_LOCK_POISONED".to_string())?; + let connection = open_ledger(app)?; + let previous_receipt_hash = connection + .query_row( + "SELECT receipt_hash FROM receipts ORDER BY sequence DESC LIMIT 1", + [], + |row| row.get::<_, String>(0), + ) + .optional() + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_LEDGER_READ_FAILED: {error}"))? + .unwrap_or_else(|| "0".repeat(64)); + let receipt_id = format!("HLP-NIPC-RECEIPT-{}", Uuid::new_v4().simple()); + let receipt_hash = sha256_hex( + format!( + "HLP-NIPC-RECEIPT-v1\n{previous_receipt_hash}\n{receipt_id}\n{event_state}\n{decision}\n{operation_number}\n{payload_sha256}\n{authority_binding_sha256}\n{now}\n{}", + error.as_deref().unwrap_or("") + ) + .as_bytes(), + ); + connection + .execute( + "INSERT INTO receipts(receipt_id,state,decision,operation_number,payload_sha256, + authority_binding_sha256,observed_at_unix_ms,previous_receipt_hash,receipt_hash,error) + VALUES(?1,?2,?3,?4,?5,?6,?7,?8,?9,?10)", + params![ + receipt_id, + event_state, + decision, + operation_number, + payload_sha256, + authority_binding_sha256, + now, + previous_receipt_hash, + receipt_hash, + error, + ], + ) + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_LEDGER_APPEND_FAILED: {error}"))?; + Ok(NumberedIpcReceipt { + receipt_id, + state: event_state.into(), + decision: decision.into(), + operation_number: operation_number.into(), + payload_sha256: payload_sha256.into(), + authority_binding_sha256: authority_binding_sha256.into(), + observed_at_unix_ms: now, + previous_receipt_hash, + receipt_hash, + error, + }) +} + +#[allow(clippy::too_many_arguments)] +fn response( + app: &AppHandle, + state: &NumberedIpcState, + event_state: &str, + decision: &str, + operation_number: &str, + payload_sha256: &str, + grant: Option, + result: Option, + error: Option, + now: u64, +) -> Result { + let receipt = append_receipt( + app, + state, + event_state, + decision, + operation_number, + payload_sha256, + &sha256_hex(b"UNBOUND_AUTHORITY"), + error.clone(), + now, + )?; + Ok(NumberedIpcResponse { + schema: "hololake.numbered-ipc-response/v1", + decision: decision.into(), + grant, + result, + error, + receipt, + }) +} + +#[allow(clippy::too_many_arguments)] +fn bound_response( + app: &AppHandle, + state: &NumberedIpcState, + authority_binding: &str, + event_state: &str, + decision: &str, + operation_number: &str, + payload_sha256: &str, + grant: Option, + result: Option, + error: Option, + now: u64, +) -> Result { + let receipt = append_receipt( + app, + state, + event_state, + decision, + operation_number, + payload_sha256, + &sha256_hex(authority_binding.as_bytes()), + error.clone(), + now, + )?; + Ok(NumberedIpcResponse { + schema: "hololake.numbered-ipc-response/v1", + decision: decision.into(), + grant, + result, + error, + receipt, + }) +} + +pub(crate) fn start_on_application_open(app: &AppHandle) -> Result<(), String> { + let _ = load_registry()?; + let _ = open_ledger(app)?; + Ok(()) +} + +#[tauri::command] +pub async fn numbered_ipc( + app: AppHandle, + state: State<'_, NumberedIpcState>, + input: Value, +) -> Result { + let now = now_unix_ms(); + let request: NumberedIpcInput = serde_json::from_value(input) + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_ENVELOPE_INVALID: {error}"))?; + let registry = load_registry()?; + let operation_number = request.envelope.coordinate.operation_number.clone(); + let digest = payload_digest(&request.envelope.payload).unwrap_or_default(); + let route = match resolve_route(®istry, &request.envelope.coordinate) { + Ok(route) => route, + Err(error) => { + return response( + &app, + &state, + "ROUTE_REJECTED", + "DENY", + &operation_number, + &digest, + None, + None, + Some(error), + now, + ) + } + }; + let authority_binding = match enforce_admission(&app, route) { + Ok(binding) => binding, + Err(error) => { + return response( + &app, + &state, + "ADMISSION_REJECTED", + "DENY", + &operation_number, + &digest, + None, + None, + Some(error), + now, + ) + } + }; + match request.action { + NumberedIpcAction::IssueGrant => { + if request.grant.is_some() { + return bound_response( + &app, + &state, + &authority_binding, + "GRANT_REJECTED", + "DENY", + &operation_number, + &digest, + None, + None, + Some("HOLOLAKE_NUMBERED_IPC_UNEXPECTED_GRANT".into()), + now, + ); + } + match issue_grant_at( + &state, + ®istry, + &request.envelope, + &authority_binding, + now, + ) { + Ok((grant, payload_sha256)) => bound_response( + &app, + &state, + &authority_binding, + "GRANT_ISSUED", + "ALLOW", + &operation_number, + &payload_sha256, + Some(grant), + None, + None, + now, + ), + Err(error) => bound_response( + &app, + &state, + &authority_binding, + "GRANT_REJECTED", + "DENY", + &operation_number, + &digest, + None, + None, + Some(error), + now, + ), + } + } + NumberedIpcAction::Execute => { + let Some(grant) = request.grant.as_ref() else { + return bound_response( + &app, + &state, + &authority_binding, + "EXECUTION_REJECTED", + "DENY", + &operation_number, + &digest, + None, + None, + Some("HOLOLAKE_NUMBERED_IPC_GRANT_REQUIRED".into()), + now, + ); + }; + let payload_sha256 = match consume_grant_at( + &state, + ®istry, + &request.envelope, + grant, + &authority_binding, + now, + ) { + Ok(payload_sha256) => payload_sha256, + Err(error) => { + return bound_response( + &app, + &state, + &authority_binding, + "EXECUTION_REJECTED", + "DENY", + &operation_number, + &digest, + None, + None, + Some(error), + now, + ) + } + }; + match crate::numbered_ipc_dispatch::dispatch( + app.clone(), + &route.handler, + request.envelope.payload, + ) + .await + { + Ok(result) => bound_response( + &app, + &state, + &authority_binding, + "EXECUTED", + "ALLOW", + &operation_number, + &payload_sha256, + None, + Some(result), + None, + now_unix_ms(), + ), + Err(error) => bound_response( + &app, + &state, + &authority_binding, + "HANDLER_REJECTED", + "DENY", + &operation_number, + &payload_sha256, + None, + None, + Some(error), + now_unix_ms(), + ), + } + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn envelope_for(route: &OperationRoute, payload: Value) -> NumberedEnvelope { + NumberedEnvelope { + coordinate: NumberedCoordinate { + protocol_version: "HLP-NIPC-v1".into(), + caller_number: "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001".into(), + channel_number: route.channel_number.clone(), + module_number: route.module_number.clone(), + operation_number: route.operation_number.clone(), + target_number: route.target_number.clone(), + request_nonce: format!("test-{}", Uuid::new_v4().simple()), + }, + requested_ttl_ms: 1_000, + payload, + } + } + + #[test] + fn registry_is_closed_and_contains_every_migrated_command() { + let registry = load_registry().unwrap(); + assert_eq!(registry.operations.len(), 62); + assert!(!registry.runtime.legacy_direct_commands_allowed); + } + + #[test] + fn route_coordinates_cannot_be_mixed() { + let registry = load_registry().unwrap(); + let mut envelope = envelope_for(®istry.operations[0], Value::Null); + envelope.coordinate.target_number = registry.operations[1].target_number.clone(); + assert_eq!( + resolve_route(®istry, &envelope.coordinate).unwrap_err(), + "HOLOLAKE_NUMBERED_IPC_ROUTE_COORDINATE_MISMATCH" + ); + } + + #[test] + fn grant_is_payload_bound_single_use_and_expires() { + let registry = load_registry().unwrap(); + let state = NumberedIpcState::default(); + let route = registry + .operations + .iter() + .find(|route| route.alias == "confirm_hololake_update_install") + .unwrap(); + let envelope = envelope_for(route, serde_json::json!({"input": {"a": 1}})); + let authority = "VERIFIED_HUMAN:ICE_GL:test-user"; + let (grant, _) = issue_grant_at(&state, ®istry, &envelope, authority, 100).unwrap(); + assert!(consume_grant_at(&state, ®istry, &envelope, &grant, authority, 101).is_ok()); + assert_eq!( + consume_grant_at(&state, ®istry, &envelope, &grant, authority, 102).unwrap_err(), + "HOLOLAKE_NUMBERED_IPC_GRANT_UNKNOWN_OR_REPLAYED" + ); + + let (expired, _) = issue_grant_at(&state, ®istry, &envelope, authority, 200).unwrap(); + assert_eq!( + consume_grant_at(&state, ®istry, &envelope, &expired, authority, 1_201,) + .unwrap_err(), + "HOLOLAKE_NUMBERED_IPC_GRANT_MISMATCH_OR_EXPIRED" + ); + + let changed = envelope_for(route, serde_json::json!({"input": {"a": 2}})); + let (bound, _) = issue_grant_at(&state, ®istry, &changed, authority, 300).unwrap(); + let mut tampered = changed.clone(); + tampered.payload = serde_json::json!({"input": {"a": 3}}); + assert_eq!( + consume_grant_at(&state, ®istry, &tampered, &bound, authority, 301).unwrap_err(), + "HOLOLAKE_NUMBERED_IPC_GRANT_MISMATCH_OR_EXPIRED" + ); + + let (rebound, _) = issue_grant_at(&state, ®istry, &envelope, authority, 400).unwrap(); + assert_eq!( + consume_grant_at( + &state, + ®istry, + &envelope, + &rebound, + "VERIFIED_HUMAN:TCS_GL:other-user", + 401, + ) + .unwrap_err(), + "HOLOLAKE_NUMBERED_IPC_GRANT_MISMATCH_OR_EXPIRED" + ); + } + + #[test] + fn payload_outer_shape_is_closed_before_a_grant_is_issued() { + let registry = load_registry().unwrap(); + let empty_route = registry + .operations + .iter() + .find(|route| route.alias == "get_hololake_home_status") + .unwrap(); + assert!(validate_payload_shape(®istry, empty_route, &serde_json::json!({})).is_ok()); + assert_eq!( + validate_payload_shape( + ®istry, + empty_route, + &serde_json::json!({"unexpected": true}), + ) + .unwrap_err(), + "HOLOLAKE_NUMBERED_IPC_PAYLOAD_FIELD_UNKNOWN" + ); + + let direct_route = registry + .operations + .iter() + .find(|route| route.alias == "perform_code_repo_login") + .unwrap(); + assert!(validate_payload_shape( + ®istry, + direct_route, + &serde_json::json!({"username": "u", "password": "p"}), + ) + .is_ok()); + assert_eq!( + validate_payload_shape( + ®istry, + direct_route, + &serde_json::json!({"username": "u", "password": "p", "role": "admin"}), + ) + .unwrap_err(), + "HOLOLAKE_NUMBERED_IPC_DIRECT_FIELDS_INVALID" + ); + } +} diff --git a/product-source/hololake-native-desktop/src-tauri/src/numbered_ipc_dispatch.rs b/product-source/hololake-native-desktop/src-tauri/src/numbered_ipc_dispatch.rs new file mode 100644 index 000000000..b995e275b --- /dev/null +++ b/product-source/hololake-native-desktop/src-tauri/src/numbered_ipc_dispatch.rs @@ -0,0 +1,303 @@ +//! Internal dispatch table for the numbered IPC root. +//! +//! This module is deliberately not a Tauri command surface. The webview can reach these +//! handlers only after `numbered_ipc` validates the full numbered coordinate and a +//! single-use, payload-bound grant. + +use serde::de::DeserializeOwned; +use serde::Serialize; +use serde_json::Value; +use tauri::{AppHandle, Manager}; + +fn input(payload: &Value) -> Result { + let value = payload + .get("input") + .cloned() + .ok_or_else(|| "HOLOLAKE_NUMBERED_IPC_INPUT_REQUIRED".to_string())?; + serde_json::from_value(value) + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_INPUT_INVALID: {error}")) +} + +fn string_field(payload: &Value, field: &str) -> Result { + payload + .get(field) + .and_then(Value::as_str) + .map(str::to_owned) + .ok_or_else(|| format!("HOLOLAKE_NUMBERED_IPC_FIELD_REQUIRED: {field}")) +} + +fn json(value: T) -> Result { + serde_json::to_value(value) + .map_err(|error| format!("HOLOLAKE_NUMBERED_IPC_RESULT_INVALID: {error}")) +} + +pub(crate) async fn dispatch( + app: AppHandle, + handler: &str, + payload: Value, +) -> Result { + match handler { + "home_status::get_hololake_home_status" => { + json(crate::home_status::get_hololake_home_status( + app.clone(), + app.state::(), + )?) + } + "release_update::check_hololake_update" => { + json(crate::release_update::check_hololake_update(app).await?) + } + "release_update::confirm_hololake_update_install" => json( + crate::release_update::confirm_hololake_update_install(app, input(&payload)?).await?, + ), + "release_update::get_hololake_release_recovery_status" => json( + crate::release_update::get_hololake_release_recovery_status(app)?, + ), + "release_update::confirm_hololake_release_health" => { + json(crate::release_update::confirm_hololake_release_health(app)?) + } + "release_update::rollback_hololake_update" => { + json(crate::release_update::rollback_hololake_update(app)?) + } + "direct_local_session::issue_direct_local_discovery_ticket" => json( + crate::direct_local_session::issue_direct_local_discovery_ticket(app, input(&payload)?) + .await?, + ), + "direct_local_session::open_direct_local_session" => json( + crate::direct_local_session::open_direct_local_session(app, input(&payload)?).await?, + ), + "direct_local_session::resume_direct_local_session" => json( + crate::direct_local_session::resume_direct_local_session(app, input(&payload)?).await?, + ), + "direct_local_session::append_direct_local_session_event" => json( + crate::direct_local_session::append_direct_local_session_event(app, input(&payload)?) + .await?, + ), + "direct_local_session::heartbeat_direct_local_session" => json( + crate::direct_local_session::heartbeat_direct_local_session(app, input(&payload)?) + .await?, + ), + "direct_local_broker::get_nearby_ai_discovery" => { + json(crate::direct_local_broker::get_nearby_ai_discovery()) + } + "gls_protocol_runtime::get_gls_protocol_runtime" => { + json(crate::gls_protocol_runtime::get_gls_protocol_runtime().await?) + } + "gls_protocol_kernel::get_gls_protocol_kernel" => { + json(crate::gls_protocol_kernel::get_gls_protocol_kernel(app).await?) + } + "gls_protocol_kernel::decide_gls_protocol" => json( + crate::gls_protocol_kernel::decide_gls_protocol( + app, + payload.get("input").cloned().unwrap_or(Value::Null), + ) + .await?, + ), + "gls_protocol_kernel::compile_gls_hldp_program" => json( + crate::gls_protocol_kernel::compile_gls_hldp_program( + app, + payload.get("input").cloned().unwrap_or(Value::Null), + ) + .await?, + ), + "local_development_bridge::acquire_development_write_lane" => json( + crate::local_development_bridge::acquire_development_write_lane(app, input(&payload)?) + .await?, + ), + "local_development_bridge::inspect_development_write_lane" => json( + crate::local_development_bridge::inspect_development_write_lane(app, input(&payload)?) + .await?, + ), + "local_development_bridge::release_development_write_lane" => json( + crate::local_development_bridge::release_development_write_lane(app, input(&payload)?) + .await?, + ), + "personal_channel::get_personal_channel_snapshot" => { + json(crate::personal_channel::get_personal_channel_snapshot(app).await?) + } + "personal_channel::initialize_personal_channel" => { + json(crate::personal_channel::initialize_personal_channel(app, input(&payload)?).await?) + } + "personal_channel::create_personal_channel_task" => json( + crate::personal_channel::create_personal_channel_task(app, input(&payload)?).await?, + ), + "personal_channel::transition_personal_channel_task" => json( + crate::personal_channel::transition_personal_channel_task(app, input(&payload)?) + .await?, + ), + "persona_time_authority::issue_persona_time_ticket" => json( + crate::persona_time_authority::issue_persona_time_ticket(app, input(&payload)?).await?, + ), + "persona_time_authority::start_persona_time_authority" => { + json(crate::persona_time_authority::start_persona_time_authority().await?) + } + "persona_time_authority::get_beijing_time_coordinate" => { + json(crate::persona_time_authority::get_beijing_time_coordinate()?) + } + "persona_time_authority::get_guanghu_era_timeline" => { + json(crate::persona_time_authority::get_guanghu_era_timeline()?) + } + "knowledge_base::get_knowledge_snapshot" => { + json(crate::knowledge_base::get_knowledge_snapshot(app).await?) + } + "knowledge_base::read_knowledge_document" => { + json(crate::knowledge_base::read_knowledge_document(app, input(&payload)?).await?) + } + "knowledge_base::search_knowledge" => { + json(crate::knowledge_base::search_knowledge(app, input(&payload)?).await?) + } + "knowledge_base::save_knowledge_document" => { + json(crate::knowledge_base::save_knowledge_document(app, input(&payload)?).await?) + } + "knowledge_base::select_and_import_knowledge_folder" => { + json(crate::knowledge_base::select_and_import_knowledge_folder(app).await?) + } + "knowledge_base::export_knowledge_document" => { + json(crate::knowledge_base::export_knowledge_document(app, input(&payload)?).await?) + } + "knowledge_base::create_knowledge_document" => { + json(crate::knowledge_base::create_knowledge_document(app, input(&payload)?).await?) + } + "knowledge_base::delete_knowledge_document" => { + json(crate::knowledge_base::delete_knowledge_document(app, input(&payload)?).await?) + } + "knowledge_base::delete_knowledge_folder" => { + json(crate::knowledge_base::delete_knowledge_folder(app, input(&payload)?).await?) + } + "knowledge_base::print_knowledge_document" => { + crate::knowledge_base::print_knowledge_document(app).await?; + Ok(Value::Null) + } + "code_channel::get_code_channel_snapshot" => { + json(crate::code_channel::get_code_channel_snapshot(app).await?) + } + "code_channel::clone_code_channel" => { + json(crate::code_channel::clone_code_channel(app, input(&payload)?).await?) + } + "code_channel::select_local_code_channel" => { + json(crate::code_channel::select_local_code_channel(app).await?) + } + "code_channel::browse_code_channel" => { + json(crate::code_channel::browse_code_channel(app, input(&payload)?).await?) + } + "code_channel::read_code_channel_file" => { + json(crate::code_channel::read_code_channel_file(app, input(&payload)?).await?) + } + "pncc_repository_binding::inspect_mounted_pncc_repository" => json( + crate::pncc_repository_binding::inspect_mounted_pncc_repository(app, input(&payload)?) + .await?, + ), + "pncc_repository_binding::select_pncc_repository_candidate" => { + json(crate::pncc_repository_binding::select_pncc_repository_candidate(app).await?) + } + "pncc_repository_binding::confirm_pncc_repository_mount" => json( + crate::pncc_repository_binding::confirm_pncc_repository_mount(app, input(&payload)?) + .await?, + ), + "pncc_receipt_projection::query_pncc_receipt_projection" => json( + crate::pncc_receipt_projection::query_pncc_receipt_projection(app, input(&payload)?) + .await?, + ), + "pncc_server_projection::query_jd_pncc_server_projection" => { + json(crate::pncc_server_projection::query_jd_pncc_server_projection().await?) + } + "code_repo_login::check_code_repo_login" => { + json(crate::code_repo_login::check_code_repo_login( + app.clone(), + app.state::(), + )?) + } + "code_repo_login::perform_code_repo_login" => json( + crate::code_repo_login::perform_code_repo_login( + app.clone(), + app.state::(), + string_field(&payload, "username")?, + string_field(&payload, "password")?, + ) + .await?, + ), + "code_repo_login::change_first_login_password" => json( + crate::code_repo_login::change_first_login_password( + app.state::(), + string_field(&payload, "username")?, + string_field(&payload, "currentPassword")?, + string_field(&payload, "newPassword")?, + ) + .await?, + ), + "code_repo_login::get_enterprise_entry" => json( + crate::code_repo_login::get_enterprise_entry( + app.clone(), + app.state::(), + ) + .await?, + ), + "code_repo_login::confirm_enterprise_persona_relationship" => json( + crate::code_repo_login::confirm_enterprise_persona_relationship( + app.clone(), + app.state::(), + string_field(&payload, "decision")?, + string_field(&payload, "idempotencyKey")?, + ) + .await?, + ), + "code_repo_login::submit_enterprise_responsibility_receipt" => json( + crate::code_repo_login::submit_enterprise_responsibility_receipt( + app.clone(), + app.state::(), + string_field(&payload, "decision")?, + string_field(&payload, "note")?, + string_field(&payload, "responsibilityVersion")?, + string_field(&payload, "idempotencyKey")?, + ) + .await?, + ), + "enterprise_work_channel::ensure_enterprise_work_channel" => json( + crate::enterprise_work_channel::ensure_enterprise_work_channel( + app.clone(), + app.state::(), + ) + .await?, + ), + "code_repo_login::sign_out_code_repo_login" => { + crate::code_repo_login::sign_out_code_repo_login(app)?; + Ok(Value::Null) + } + "user_pncc_channel::get_user_pncc_channel" => json( + crate::user_pncc_channel::get_user_pncc_channel( + app.clone(), + app.state::(), + ) + .await?, + ), + "user_pncc_channel::ensure_user_pncc_channel" => json( + crate::user_pncc_channel::ensure_user_pncc_channel( + app.clone(), + app.state::(), + ) + .await?, + ), + "zero_core_numbering::get_zero_core_numbering_kernel" => { + json(crate::zero_core_numbering::get_zero_core_numbering_kernel().await?) + } + "zero_point::zero_point_bind" => json( + crate::zero_point::zero_point_bind( + app.state::(), + payload.get("input").cloned().unwrap_or(Value::Null), + ) + .await?, + ), + "zero_point::zero_point_verify" => json( + crate::zero_point::zero_point_verify(app.state::()) + .await?, + ), + "zero_point::zero_point_sync" => json( + crate::zero_point::zero_point_sync(app.state::()) + .await?, + ), + "zero_point::zero_point_status" => json( + crate::zero_point::zero_point_status(app.state::()) + .await?, + ), + _ => Err("HOLOLAKE_NUMBERED_IPC_HANDLER_UNKNOWN".into()), + } +} diff --git a/product-source/hololake-native-desktop/src-tauri/src/persona_time_authority.rs b/product-source/hololake-native-desktop/src-tauri/src/persona_time_authority.rs index 44f4f8423..f8ca4d35f 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/persona_time_authority.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/persona_time_authority.rs @@ -161,7 +161,6 @@ pub(crate) struct VerifiedTicketRequest { pub session: AuthenticatedSessionContext, } -#[tauri::command] pub async fn issue_persona_time_ticket( app: AppHandle, input: IssuePersonaTimeTicketInput, @@ -181,7 +180,6 @@ pub fn start_on_application_open() { }); } -#[tauri::command] pub async fn start_persona_time_authority() -> Result { let already_synchronized = network_anchor()?.is_some(); let synchronization_attempted = !already_synchronized; @@ -225,12 +223,10 @@ pub(crate) fn issue_authenticated_at( ) } -#[tauri::command] pub fn get_beijing_time_coordinate() -> Result { beijing_time_coordinate_from_sample(reality_time_sample()?) } -#[tauri::command] pub fn get_guanghu_era_timeline() -> Result { guanghu_era_timeline_from_sample(reality_time_sample()?) } diff --git a/product-source/hololake-native-desktop/src-tauri/src/personal_channel.rs b/product-source/hololake-native-desktop/src-tauri/src/personal_channel.rs index 26f62082b..5161ec927 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/personal_channel.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/personal_channel.rs @@ -119,7 +119,6 @@ struct EventHashPayload<'a> { occurred_at_unix_ms: i64, } -#[tauri::command] pub async fn get_personal_channel_snapshot( app: AppHandle, ) -> Result { @@ -129,7 +128,6 @@ pub async fn get_personal_channel_snapshot( .map_err(|error| format!("HOLOLAKE_PERSONAL_CHANNEL_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn initialize_personal_channel( app: AppHandle, input: InitializePersonalChannelInput, @@ -140,7 +138,6 @@ pub async fn initialize_personal_channel( .map_err(|error| format!("HOLOLAKE_PERSONAL_CHANNEL_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn create_personal_channel_task( app: AppHandle, input: CreatePersonalChannelTaskInput, @@ -151,7 +148,6 @@ pub async fn create_personal_channel_task( .map_err(|error| format!("HOLOLAKE_PERSONAL_CHANNEL_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn transition_personal_channel_task( app: AppHandle, input: TransitionPersonalChannelTaskInput, diff --git a/product-source/hololake-native-desktop/src-tauri/src/pncc_receipt_projection.rs b/product-source/hololake-native-desktop/src-tauri/src/pncc_receipt_projection.rs index c4fc1f877..25e77f957 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/pncc_receipt_projection.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/pncc_receipt_projection.rs @@ -78,7 +78,6 @@ struct ProjectionInput { source_receipt_id: String, } -#[tauri::command] pub async fn query_pncc_receipt_projection( app: AppHandle, input: QueryPnccReceiptProjectionInput, @@ -90,7 +89,8 @@ pub async fn query_pncc_receipt_projection( } pub(crate) fn pncc_projection_root(app: &AppHandle) -> Result { - let root = crate::authenticated_storage::account_storage_root(app, "pncc-receipt-projection-v1")?; + let root = + crate::authenticated_storage::account_storage_root(app, "pncc-receipt-projection-v1")?; fs::create_dir_all(&root) .map_err(|error| format!("PNCC_PROJECTION_STORAGE_UNAVAILABLE: {error}"))?; root.canonicalize() diff --git a/product-source/hololake-native-desktop/src-tauri/src/pncc_repository_binding.rs b/product-source/hololake-native-desktop/src-tauri/src/pncc_repository_binding.rs index 6162d71fc..bd8bc5844 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/pncc_repository_binding.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/pncc_repository_binding.rs @@ -109,7 +109,6 @@ pub struct InspectPnccRepositoryInput { pub expected_head: String, } -#[tauri::command] pub async fn inspect_mounted_pncc_repository( app: AppHandle, input: InspectMountedPnccRepositoryInput, @@ -120,7 +119,6 @@ pub async fn inspect_mounted_pncc_repository( .map_err(|error| format!("PNCC_REPOSITORY_MOUNT_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn select_pncc_repository_candidate( app: AppHandle, ) -> Result, String> { @@ -148,7 +146,6 @@ pub async fn select_pncc_repository_candidate( create_candidate_at(&candidate_root, inspection).map(Some) } -#[tauri::command] pub async fn confirm_pncc_repository_mount( app: AppHandle, input: ConfirmPnccRepositoryMountInput, @@ -166,7 +163,8 @@ pub async fn confirm_pncc_repository_mount( } pub(crate) fn pncc_repository_mount_root(app: &AppHandle) -> Result { - let root = crate::authenticated_storage::account_storage_root(app, "pncc-repository-mounts-v1")?; + let root = + crate::authenticated_storage::account_storage_root(app, "pncc-repository-mounts-v1")?; fs::create_dir_all(&root) .map_err(|error| format!("PNCC_REPOSITORY_MOUNT_STORAGE_UNAVAILABLE: {error}"))?; root.canonicalize() @@ -174,7 +172,8 @@ pub(crate) fn pncc_repository_mount_root(app: &AppHandle) -> Result Result { - let root = crate::authenticated_storage::account_storage_root(app, "pncc-repository-candidates-v1")?; + let root = + crate::authenticated_storage::account_storage_root(app, "pncc-repository-candidates-v1")?; fs::create_dir_all(&root) .map_err(|error| format!("PNCC_REPOSITORY_CANDIDATE_STORAGE_UNAVAILABLE: {error}"))?; root.canonicalize() diff --git a/product-source/hololake-native-desktop/src-tauri/src/pncc_server_projection.rs b/product-source/hololake-native-desktop/src-tauri/src/pncc_server_projection.rs index fd6ec1fc3..eae653da4 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/pncc_server_projection.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/pncc_server_projection.rs @@ -117,7 +117,6 @@ fn parse_projection(bytes: &[u8]) -> Result { }) } -#[tauri::command] pub async fn query_jd_pncc_server_projection() -> Result { tauri::async_runtime::spawn_blocking(|| { let executable = if cfg!(windows) { "ssh" } else { "/usr/bin/ssh" }; diff --git a/product-source/hololake-native-desktop/src-tauri/src/release_update.rs b/product-source/hololake-native-desktop/src-tauri/src/release_update.rs index 5d0bec7ce..7d27322e2 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/release_update.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/release_update.rs @@ -206,7 +206,6 @@ pub struct ReleaseRecoveryReceipt { pub receipt_id: String, } -#[tauri::command] pub async fn check_hololake_update(app: AppHandle) -> Result { let trust = provisioned_release_trust()? .ok_or_else(|| "HOLOLAKE_RELEASE_TRUST_UNPROVISIONED_NO_NETWORK_REQUEST".to_string())?; @@ -238,7 +237,6 @@ pub async fn check_hololake_update(app: AppHandle) -> Result Result { release_recovery_status_at(&release_update_root(&app)?) } -#[tauri::command] pub fn confirm_hololake_release_health(app: AppHandle) -> Result { let root = release_update_root(&app)?; let _lock = lock(&root)?; @@ -391,7 +387,6 @@ pub fn confirm_hololake_release_health(app: AppHandle) -> Result Result { let root = release_update_root(&app)?; let _lock = lock(&root)?; @@ -414,7 +409,6 @@ pub fn rollback_hololake_update(app: AppHandle) -> Result Result { Err("HOLOLAKE_RELEASE_WINDOWS_LOCAL_ROLLBACK_NOT_AVAILABLE".into()) } diff --git a/product-source/hololake-native-desktop/src-tauri/src/user_pncc_channel.rs b/product-source/hololake-native-desktop/src-tauri/src/user_pncc_channel.rs index 9966f0b60..aef787447 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/user_pncc_channel.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/user_pncc_channel.rs @@ -57,7 +57,6 @@ pub struct UserPnccChannelSnapshot { pub authority: &'static str, } -#[tauri::command] pub async fn get_user_pncc_channel( app: AppHandle, state: State<'_, ZeroPointState>, @@ -77,7 +76,6 @@ pub async fn get_user_pncc_channel( .map_err(|error| format!("HOLOLAKE_USER_PNCC_JOIN_FAILED: {error}"))? } -#[tauri::command] pub async fn ensure_user_pncc_channel( app: AppHandle, state: State<'_, ZeroPointState>, diff --git a/product-source/hololake-native-desktop/src-tauri/src/zero_core_numbering.rs b/product-source/hololake-native-desktop/src-tauri/src/zero_core_numbering.rs index e805b6fc3..03f2957af 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/zero_core_numbering.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/zero_core_numbering.rs @@ -190,7 +190,6 @@ pub(crate) fn resolve_human_number_route(number: &str) -> Result Result { let contract = load_contract()?; Ok(ZeroCoreNumberingKernelSnapshot { diff --git a/product-source/hololake-native-desktop/src-tauri/src/zero_point.rs b/product-source/hololake-native-desktop/src-tauri/src/zero_point.rs index c8d8ee0f9..d40386c98 100644 --- a/product-source/hololake-native-desktop/src-tauri/src/zero_point.rs +++ b/product-source/hololake-native-desktop/src-tauri/src/zero_point.rs @@ -290,7 +290,6 @@ pub(crate) fn verified_user_route( } /// 登录绑定：用户编号入仓（等待绑定态→绑定态）。空白态拒绝一切唤醒。 -#[tauri::command] pub async fn zero_point_bind( state: State<'_, ZeroPointState>, input: serde_json::Value, @@ -320,7 +319,6 @@ pub async fn zero_point_bind( } /// 通过登记服务执行三态裁决：PASS / REJECT / OFFLINE，并应用离线宽限期。 -#[tauri::command] pub async fn zero_point_verify( state: State<'_, ZeroPointState>, ) -> Result { @@ -516,7 +514,6 @@ pub async fn sync_protocol_runtime(state: &ZeroPointState) -> Result<(), String> Ok(()) } -#[tauri::command] pub async fn zero_point_sync( state: State<'_, ZeroPointState>, ) -> Result { @@ -525,7 +522,6 @@ pub async fn zero_point_sync( } /// 返回当前编号验证与协议状态快照。 -#[tauri::command] pub async fn zero_point_status( state: State<'_, ZeroPointState>, ) -> Result { diff --git a/product-source/hololake-native-desktop/src/main.tsx b/product-source/hololake-native-desktop/src/main.tsx index 0b51be164..6d65a27c2 100644 --- a/product-source/hololake-native-desktop/src/main.tsx +++ b/product-source/hololake-native-desktop/src/main.tsx @@ -1,6 +1,6 @@ import { StrictMode, useCallback, useEffect, useMemo, useRef, useState } from 'react' import { createRoot } from 'react-dom/client' -import { invoke } from '@tauri-apps/api/core' +import { numberedInvoke as invoke } from './modules/numbered-ipc' import { splitFrontmatter, documentOutline, jumpToHeading, MarkdownDocument, markdownHtml } from './modules/knowledge-render' const TAG_TINTS = ['tag-lavender', 'tag-sky', 'tag-mint', 'tag-amber', 'tag-rose', 'tag-slate'] diff --git a/product-source/hololake-native-desktop/src/modules/numbered-ipc.ts b/product-source/hololake-native-desktop/src/modules/numbered-ipc.ts new file mode 100644 index 000000000..8aa9ac8e4 --- /dev/null +++ b/product-source/hololake-native-desktop/src/modules/numbered-ipc.ts @@ -0,0 +1,562 @@ +import { invoke } from '@tauri-apps/api/core' + +const ROUTES = { + "get_hololake_home_status": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0001", + "operationNumber": "HLP-NIPC-OP-0001", + "targetNumber": "HLP-NIPC-TGT-0001" + }, + "check_hololake_update": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0002", + "operationNumber": "HLP-NIPC-OP-0002", + "targetNumber": "HLP-NIPC-TGT-0002" + }, + "confirm_hololake_update_install": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0002", + "operationNumber": "HLP-NIPC-OP-0003", + "targetNumber": "HLP-NIPC-TGT-0002" + }, + "get_hololake_release_recovery_status": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0002", + "operationNumber": "HLP-NIPC-OP-0004", + "targetNumber": "HLP-NIPC-TGT-0002" + }, + "confirm_hololake_release_health": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0002", + "operationNumber": "HLP-NIPC-OP-0005", + "targetNumber": "HLP-NIPC-TGT-0002" + }, + "rollback_hololake_update": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0002", + "operationNumber": "HLP-NIPC-OP-0006", + "targetNumber": "HLP-NIPC-TGT-0002" + }, + "issue_direct_local_discovery_ticket": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0003", + "moduleNumber": "HLP-NIPC-MOD-0003", + "operationNumber": "HLP-NIPC-OP-0007", + "targetNumber": "HLP-NIPC-TGT-0003" + }, + "open_direct_local_session": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0003", + "moduleNumber": "HLP-NIPC-MOD-0003", + "operationNumber": "HLP-NIPC-OP-0008", + "targetNumber": "HLP-NIPC-TGT-0003" + }, + "resume_direct_local_session": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0003", + "moduleNumber": "HLP-NIPC-MOD-0003", + "operationNumber": "HLP-NIPC-OP-0009", + "targetNumber": "HLP-NIPC-TGT-0003" + }, + "append_direct_local_session_event": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0003", + "moduleNumber": "HLP-NIPC-MOD-0003", + "operationNumber": "HLP-NIPC-OP-0010", + "targetNumber": "HLP-NIPC-TGT-0003" + }, + "heartbeat_direct_local_session": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0003", + "moduleNumber": "HLP-NIPC-MOD-0003", + "operationNumber": "HLP-NIPC-OP-0011", + "targetNumber": "HLP-NIPC-TGT-0003" + }, + "get_nearby_ai_discovery": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0003", + "moduleNumber": "HLP-NIPC-MOD-0004", + "operationNumber": "HLP-NIPC-OP-0012", + "targetNumber": "HLP-NIPC-TGT-0004" + }, + "get_gls_protocol_runtime": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0005", + "operationNumber": "HLP-NIPC-OP-0013", + "targetNumber": "HLP-NIPC-TGT-0005" + }, + "get_gls_protocol_kernel": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0006", + "operationNumber": "HLP-NIPC-OP-0014", + "targetNumber": "HLP-NIPC-TGT-0006" + }, + "decide_gls_protocol": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0006", + "operationNumber": "HLP-NIPC-OP-0015", + "targetNumber": "HLP-NIPC-TGT-0006" + }, + "compile_gls_hldp_program": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0006", + "operationNumber": "HLP-NIPC-OP-0016", + "targetNumber": "HLP-NIPC-TGT-0006" + }, + "acquire_development_write_lane": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0004", + "moduleNumber": "HLP-NIPC-MOD-0007", + "operationNumber": "HLP-NIPC-OP-0017", + "targetNumber": "HLP-NIPC-TGT-0007" + }, + "inspect_development_write_lane": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0004", + "moduleNumber": "HLP-NIPC-MOD-0007", + "operationNumber": "HLP-NIPC-OP-0018", + "targetNumber": "HLP-NIPC-TGT-0007" + }, + "release_development_write_lane": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0004", + "moduleNumber": "HLP-NIPC-MOD-0007", + "operationNumber": "HLP-NIPC-OP-0019", + "targetNumber": "HLP-NIPC-TGT-0007" + }, + "get_personal_channel_snapshot": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0008", + "operationNumber": "HLP-NIPC-OP-0020", + "targetNumber": "HLP-NIPC-TGT-0008" + }, + "initialize_personal_channel": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0008", + "operationNumber": "HLP-NIPC-OP-0021", + "targetNumber": "HLP-NIPC-TGT-0008" + }, + "create_personal_channel_task": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0008", + "operationNumber": "HLP-NIPC-OP-0022", + "targetNumber": "HLP-NIPC-TGT-0008" + }, + "transition_personal_channel_task": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0008", + "operationNumber": "HLP-NIPC-OP-0023", + "targetNumber": "HLP-NIPC-TGT-0008" + }, + "issue_persona_time_ticket": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0009", + "operationNumber": "HLP-NIPC-OP-0024", + "targetNumber": "HLP-NIPC-TGT-0009" + }, + "start_persona_time_authority": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0009", + "operationNumber": "HLP-NIPC-OP-0025", + "targetNumber": "HLP-NIPC-TGT-0009" + }, + "get_beijing_time_coordinate": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0009", + "operationNumber": "HLP-NIPC-OP-0026", + "targetNumber": "HLP-NIPC-TGT-0009" + }, + "get_guanghu_era_timeline": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0009", + "operationNumber": "HLP-NIPC-OP-0027", + "targetNumber": "HLP-NIPC-TGT-0009" + }, + "get_knowledge_snapshot": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0010", + "operationNumber": "HLP-NIPC-OP-0028", + "targetNumber": "HLP-NIPC-TGT-0010" + }, + "read_knowledge_document": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0010", + "operationNumber": "HLP-NIPC-OP-0029", + "targetNumber": "HLP-NIPC-TGT-0010" + }, + "search_knowledge": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0010", + "operationNumber": "HLP-NIPC-OP-0030", + "targetNumber": "HLP-NIPC-TGT-0010" + }, + "save_knowledge_document": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0010", + "operationNumber": "HLP-NIPC-OP-0031", + "targetNumber": "HLP-NIPC-TGT-0010" + }, + "select_and_import_knowledge_folder": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0010", + "operationNumber": "HLP-NIPC-OP-0032", + "targetNumber": "HLP-NIPC-TGT-0010" + }, + "export_knowledge_document": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0010", + "operationNumber": "HLP-NIPC-OP-0033", + "targetNumber": "HLP-NIPC-TGT-0010" + }, + "create_knowledge_document": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0010", + "operationNumber": "HLP-NIPC-OP-0034", + "targetNumber": "HLP-NIPC-TGT-0010" + }, + "delete_knowledge_document": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0010", + "operationNumber": "HLP-NIPC-OP-0035", + "targetNumber": "HLP-NIPC-TGT-0010" + }, + "delete_knowledge_folder": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0010", + "operationNumber": "HLP-NIPC-OP-0036", + "targetNumber": "HLP-NIPC-TGT-0010" + }, + "print_knowledge_document": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0010", + "operationNumber": "HLP-NIPC-OP-0037", + "targetNumber": "HLP-NIPC-TGT-0010" + }, + "get_code_channel_snapshot": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0011", + "operationNumber": "HLP-NIPC-OP-0038", + "targetNumber": "HLP-NIPC-TGT-0011" + }, + "clone_code_channel": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0011", + "operationNumber": "HLP-NIPC-OP-0039", + "targetNumber": "HLP-NIPC-TGT-0011" + }, + "select_local_code_channel": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0011", + "operationNumber": "HLP-NIPC-OP-0040", + "targetNumber": "HLP-NIPC-TGT-0011" + }, + "browse_code_channel": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0011", + "operationNumber": "HLP-NIPC-OP-0041", + "targetNumber": "HLP-NIPC-TGT-0011" + }, + "read_code_channel_file": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0002", + "moduleNumber": "HLP-NIPC-MOD-0011", + "operationNumber": "HLP-NIPC-OP-0042", + "targetNumber": "HLP-NIPC-TGT-0011" + }, + "inspect_mounted_pncc_repository": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0005", + "moduleNumber": "HLP-NIPC-MOD-0012", + "operationNumber": "HLP-NIPC-OP-0043", + "targetNumber": "HLP-NIPC-TGT-0012" + }, + "select_pncc_repository_candidate": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0005", + "moduleNumber": "HLP-NIPC-MOD-0012", + "operationNumber": "HLP-NIPC-OP-0044", + "targetNumber": "HLP-NIPC-TGT-0012" + }, + "confirm_pncc_repository_mount": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0005", + "moduleNumber": "HLP-NIPC-MOD-0012", + "operationNumber": "HLP-NIPC-OP-0045", + "targetNumber": "HLP-NIPC-TGT-0012" + }, + "query_pncc_receipt_projection": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0005", + "moduleNumber": "HLP-NIPC-MOD-0013", + "operationNumber": "HLP-NIPC-OP-0046", + "targetNumber": "HLP-NIPC-TGT-0013" + }, + "query_jd_pncc_server_projection": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0005", + "moduleNumber": "HLP-NIPC-MOD-0014", + "operationNumber": "HLP-NIPC-OP-0047", + "targetNumber": "HLP-NIPC-TGT-0014" + }, + "check_code_repo_login": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0006", + "moduleNumber": "HLP-NIPC-MOD-0015", + "operationNumber": "HLP-NIPC-OP-0048", + "targetNumber": "HLP-NIPC-TGT-0015" + }, + "perform_code_repo_login": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0006", + "moduleNumber": "HLP-NIPC-MOD-0015", + "operationNumber": "HLP-NIPC-OP-0049", + "targetNumber": "HLP-NIPC-TGT-0015" + }, + "change_first_login_password": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0006", + "moduleNumber": "HLP-NIPC-MOD-0015", + "operationNumber": "HLP-NIPC-OP-0050", + "targetNumber": "HLP-NIPC-TGT-0015" + }, + "get_enterprise_entry": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0006", + "moduleNumber": "HLP-NIPC-MOD-0015", + "operationNumber": "HLP-NIPC-OP-0051", + "targetNumber": "HLP-NIPC-TGT-0015" + }, + "confirm_enterprise_persona_relationship": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0006", + "moduleNumber": "HLP-NIPC-MOD-0015", + "operationNumber": "HLP-NIPC-OP-0052", + "targetNumber": "HLP-NIPC-TGT-0015" + }, + "submit_enterprise_responsibility_receipt": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0006", + "moduleNumber": "HLP-NIPC-MOD-0015", + "operationNumber": "HLP-NIPC-OP-0053", + "targetNumber": "HLP-NIPC-TGT-0015" + }, + "ensure_enterprise_work_channel": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0007", + "moduleNumber": "HLP-NIPC-MOD-0016", + "operationNumber": "HLP-NIPC-OP-0054", + "targetNumber": "HLP-NIPC-TGT-0016" + }, + "sign_out_code_repo_login": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0006", + "moduleNumber": "HLP-NIPC-MOD-0015", + "operationNumber": "HLP-NIPC-OP-0055", + "targetNumber": "HLP-NIPC-TGT-0015" + }, + "get_user_pncc_channel": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0005", + "moduleNumber": "HLP-NIPC-MOD-0017", + "operationNumber": "HLP-NIPC-OP-0056", + "targetNumber": "HLP-NIPC-TGT-0017" + }, + "ensure_user_pncc_channel": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0005", + "moduleNumber": "HLP-NIPC-MOD-0017", + "operationNumber": "HLP-NIPC-OP-0057", + "targetNumber": "HLP-NIPC-TGT-0017" + }, + "get_zero_core_numbering_kernel": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0001", + "moduleNumber": "HLP-NIPC-MOD-0018", + "operationNumber": "HLP-NIPC-OP-0058", + "targetNumber": "HLP-NIPC-TGT-0018" + }, + "zero_point_bind": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0006", + "moduleNumber": "HLP-NIPC-MOD-0019", + "operationNumber": "HLP-NIPC-OP-0059", + "targetNumber": "HLP-NIPC-TGT-0019" + }, + "zero_point_verify": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0006", + "moduleNumber": "HLP-NIPC-MOD-0019", + "operationNumber": "HLP-NIPC-OP-0060", + "targetNumber": "HLP-NIPC-TGT-0019" + }, + "zero_point_sync": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0006", + "moduleNumber": "HLP-NIPC-MOD-0019", + "operationNumber": "HLP-NIPC-OP-0061", + "targetNumber": "HLP-NIPC-TGT-0019" + }, + "zero_point_status": { + "protocolVersion": "HLP-NIPC-v1", + "callerNumber": "HLP-NIPC-CALLER-MAIN-WEBVIEW-0001", + "channelNumber": "HLP-NIPC-CH-0006", + "moduleNumber": "HLP-NIPC-MOD-0019", + "operationNumber": "HLP-NIPC-OP-0062", + "targetNumber": "HLP-NIPC-TGT-0019" + } +} as const + +export type NumberedOperation = keyof typeof ROUTES + +interface NumberedGrant { + grantId: string + expiresAtUnixMs: number + payloadSha256: string + authorityBindingSha256: string + signature: string +} + +interface NumberedIpcResponse { + schema: 'hololake.numbered-ipc-response/v1' + decision: 'ALLOW' | 'DENY' + grant?: NumberedGrant | null + result?: T | null + error?: string | null + receipt: { + receiptId: string + state: string + decision: 'ALLOW' | 'DENY' + operationNumber: string + payloadSha256: string + authorityBindingSha256: string + observedAtUnixMs: number + previousReceiptHash: string + receiptHash: string + error?: string | null + } +} + +function requestNonce(): string { + return 'HLP-NIPC-REQ-' + crypto.randomUUID().replaceAll('-', '') +} + +function denied(response: NumberedIpcResponse): Error { + return new Error((response.error || 'HOLOLAKE_NUMBERED_IPC_DENIED') + ' [' + response.receipt.receiptId + ']') +} + +/** + * The only webview-to-native route. Aliases are compile-time ergonomics only; the + * native side receives and validates the complete numbered coordinate. + */ +export async function numberedInvoke(operation: NumberedOperation, payload: Record = {}): Promise { + const route = ROUTES[operation] + const envelope = { + ...route, + requestNonce: requestNonce(), + requestedTtlMs: 10_000, + payload, + } + const issued = await invoke>('numbered_ipc', { + input: { action: 'ISSUE_GRANT', envelope }, + }) + if (issued.decision !== 'ALLOW' || !issued.grant) throw denied(issued) + + const executed = await invoke>('numbered_ipc', { + input: { action: 'EXECUTE', envelope, grant: issued.grant }, + }) + if (executed.decision !== 'ALLOW') throw denied(executed) + return executed.result as T +}