Refactor/sdk init (#2947)

* fixes for main

* refactor package initialization

* fixes from testing

* more fixes

* beta.21

* do not use instanceof

* closes #2921

* beta22

* allow disabling kiosk

* migration

* fix /etc/shadow

* actionRequest -> task

* beta.23

core/startos/src/service/effects/action.rs

@@ -5,7 +5,7 @@ use rpc_toolkit::{from_fn_async, Context, HandlerExt, ParentHandler};
 
 use crate::action::{display_action_result, ActionInput, ActionResult};
 use crate::db::model::package::{
-    ActionMetadata, ActionRequest, ActionRequestCondition, ActionRequestEntry, ActionRequestTrigger,
+    ActionMetadata, Task, TaskCondition, TaskEntry, TaskSeverity, TaskTrigger,
 };
 use crate::rpc_continuations::Guid;
 use crate::service::cli::ContainerCliContext;
@@ -34,10 +34,10 @@ pub fn action_api<C: Context>() -> ParentHandler<C> {
                 .with_custom_display_fn(|args, res| Ok(display_action_result(args.params, res)))
                 .with_call_remote::<ContainerCliContext>(),
         )
-        .subcommand("request", from_fn_async(request_action).no_cli())
+        .subcommand("create-task", from_fn_async(create_task).no_cli())
         .subcommand(
-            "clear-requests",
-            from_fn_async(clear_action_requests)
+            "clear-tasks",
+            from_fn_async(clear_tasks)
                 .no_display()
                 .with_call_remote::<ContainerCliContext>(),
         )
@@ -196,29 +196,29 @@ async fn run_action(
 #[derive(Clone, Debug, Deserialize, Serialize, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export)]
-pub struct RequestActionParams {
+pub struct CreateTaskParams {
     #[serde(default)]
     #[ts(skip)]
     procedure_id: Guid,
     replay_id: ReplayId,
     #[serde(flatten)]
-    request: ActionRequest,
+    task: Task,
 }
-async fn request_action(
+async fn create_task(
     context: EffectContext,
-    RequestActionParams {
+    CreateTaskParams {
         procedure_id,
         replay_id,
-        request,
-    }: RequestActionParams,
+        task,
+    }: CreateTaskParams,
 ) -> Result<(), Error> {
     let context = context.deref()?;
 
     let src_id = &context.seed.id;
-    let active = match &request.when {
-        Some(ActionRequestTrigger { once, condition }) => match condition {
-            ActionRequestCondition::InputNotMatches => {
-                let Some(input) = request.input.as_ref() else {
+    let active = match &task.when {
+        Some(TaskTrigger { once, condition }) => match condition {
+            TaskCondition::InputNotMatches => {
+                let Some(input) = task.input.as_ref() else {
                     return Err(Error::new(
                         eyre!("input-not-matches trigger requires input to be specified"),
                         ErrorKind::InvalidRequest,
@@ -228,19 +228,19 @@ async fn request_action(
                     .seed
                     .ctx
                     .services
-                    .get(&request.package_id)
+                    .get(&task.package_id)
                     .await
                     .as_ref()
                 {
                     let Some(prev) = service
-                        .get_action_input(procedure_id, request.action_id.clone())
+                        .get_action_input(procedure_id.clone(), task.action_id.clone())
                         .await?
                     else {
                         return Err(Error::new(
                             eyre!(
                                 "action {} of {} has no input",
-                                request.action_id,
-                                request.package_id
+                                task.action_id,
+                                task.package_id
                             ),
                             ErrorKind::InvalidRequest,
                         ));
@@ -261,6 +261,9 @@ async fn request_action(
         },
         None => true,
     };
+    if active && task.severity == TaskSeverity::Critical {
+        context.stop(procedure_id).await?;
+    }
     context
         .seed
         .ctx
@@ -270,8 +273,8 @@ async fn request_action(
                 .as_package_data_mut()
                 .as_idx_mut(src_id)
                 .or_not_found(src_id)?
-                .as_requested_actions_mut()
-                .insert(&replay_id, &ActionRequestEntry { active, request })
+                .as_tasks_mut()
+                .insert(&replay_id, &TaskEntry { active, task })
         })
         .await
         .result?;
@@ -281,16 +284,16 @@ async fn request_action(
 #[derive(Debug, Clone, Serialize, Deserialize, TS, Parser)]
 #[ts(type = "{ only: string[] } | { except: string[] }")]
 #[ts(export)]
-pub struct ClearActionRequestsParams {
+pub struct ClearTasksParams {
     #[arg(long, conflicts_with = "except")]
     pub only: Option<Vec<ReplayId>>,
     #[arg(long, conflicts_with = "only")]
     pub except: Option<Vec<ReplayId>>,
 }
 
-async fn clear_action_requests(
+async fn clear_tasks(
     context: EffectContext,
-    ClearActionRequestsParams { only, except }: ClearActionRequestsParams,
+    ClearTasksParams { only, except }: ClearTasksParams,
 ) -> Result<(), Error> {
     let context = context.deref()?;
     let package_id = context.seed.id.clone();
@@ -305,7 +308,7 @@ async fn clear_action_requests(
                 .as_package_data_mut()
                 .as_idx_mut(&package_id)
                 .or_not_found(&package_id)?
-                .as_requested_actions_mut()
+                .as_tasks_mut()
                 .mutate(|a| {
                     Ok(a.retain(|e, _| {
                         only.as_ref().map_or(true, |only| !only.contains(e))

core/startos/src/service/effects/dependency.rs

@@ -10,7 +10,7 @@ use models::{FromStrParser, HealthCheckId, PackageId, ReplayId, VersionString, V
 use tokio::process::Command;
 
 use crate::db::model::package::{
-    ActionRequestEntry, CurrentDependencies, CurrentDependencyInfo, CurrentDependencyKind,
+    TaskEntry, CurrentDependencies, CurrentDependencyInfo, CurrentDependencyKind,
     ManifestPreference,
 };
 use crate::disk::mount::filesystem::bind::Bind;
@@ -335,7 +335,7 @@ pub struct CheckDependenciesResult {
     installed_version: Option<VersionString>,
     satisfies: BTreeSet<VersionString>,
     is_running: bool,
-    requested_actions: BTreeMap<ReplayId, ActionRequestEntry>,
+    tasks: BTreeMap<ReplayId, TaskEntry>,
     #[ts(as = "BTreeMap::<HealthCheckId, NamedHealthCheckResult>")]
     health_checks: OrdMap<HealthCheckId, NamedHealthCheckResult>,
 }
@@ -351,7 +351,7 @@ pub async fn check_dependencies(
         .as_idx(&context.seed.id)
         .or_not_found(&context.seed.id)?;
     let current_dependencies = pde.as_current_dependencies().de()?;
-    let requested_actions = pde.as_requested_actions().de()?;
+    let tasks = pde.as_tasks().de()?;
     let package_dependency_info: Vec<_> = package_ids
         .unwrap_or_else(|| current_dependencies.0.keys().cloned().collect())
         .into_iter()
@@ -365,9 +365,9 @@ pub async fn check_dependencies(
     for (package_id, dependency_info) in package_dependency_info {
         let title = dependency_info.title.clone();
         let Some(package) = db.as_public().as_package_data().as_idx(&package_id) else {
-            let requested_actions = requested_actions
+            let tasks = tasks
                 .iter()
-                .filter(|(_, v)| v.request.package_id == package_id)
+                .filter(|(_, v)| v.task.package_id == package_id)
                 .map(|(k, v)| (k.clone(), v.clone()))
                 .collect();
             results.push(CheckDependenciesResult {
@@ -376,7 +376,7 @@ pub async fn check_dependencies(
                 installed_version: None,
                 satisfies: BTreeSet::new(),
                 is_running: false,
-                requested_actions,
+                tasks,
                 health_checks: Default::default(),
             });
             continue;
@@ -393,9 +393,9 @@ pub async fn check_dependencies(
             false
         };
         let health_checks = status.health().cloned().unwrap_or_default();
-        let requested_actions = requested_actions
+        let tasks = tasks
             .iter()
-            .filter(|(_, v)| v.request.package_id == package_id)
+            .filter(|(_, v)| v.task.package_id == package_id)
             .map(|(k, v)| (k.clone(), v.clone()))
             .collect();
         results.push(CheckDependenciesResult {
@@ -404,7 +404,7 @@ pub async fn check_dependencies(
             installed_version,
             satisfies,
             is_running,
-            requested_actions,
+            tasks,
             health_checks,
         });
     }

core/startos/src/service/effects/version.rs

@@ -1,5 +1,3 @@
-use models::VersionString;
-
 use crate::service::effects::prelude::*;
 
 #[derive(Debug, Clone, Serialize, Deserialize, TS, Parser)]
@@ -7,7 +5,7 @@ use crate::service::effects::prelude::*;
 #[ts(export)]
 pub struct SetDataVersionParams {
     #[ts(type = "string")]
-    version: VersionString,
+    version: Option<String>,
 }
 pub async fn set_data_version(
     context: EffectContext,
@@ -25,7 +23,7 @@ pub async fn set_data_version(
                 .as_idx_mut(package_id)
                 .or_not_found(package_id)?
                 .as_data_version_mut()
-                .ser(&Some(version))
+                .ser(&version)
         })
         .await
         .result?;
@@ -33,7 +31,7 @@ pub async fn set_data_version(
     Ok(())
 }
 
-pub async fn get_data_version(context: EffectContext) -> Result<Option<VersionString>, Error> {
+pub async fn get_data_version(context: EffectContext) -> Result<Option<String>, Error> {
     let context = context.deref()?;
     let package_id = &context.seed.id;
     context