clanker-saddle/src/main.vala

using Astralis;
using Inversion;
using InvercargillSqlInversion;
using Spry;
using Spry.Authentication;
using Statum;
using ClankerSaddle;
using ClankerSaddle.Api;
using ClankerSaddle.Data;
using ClankerSaddle.Services;

int main(string[] args) {
    int port = args.length > 1 ? int.parse(args[1]) : 8080;
    print("ClankerSaddle - LLM task orchestration platform\n");
    print(@"Website starting on port $(port)\n");

    try {
        var application = new WebApplication(port);
        application.use_compression();
        application.add_module<StatumModule>();
        application.add_module<SpryModule>();

        var db_path = Environment.get_variable("SPRY_DB_PATH") ?? "";
        if (db_path.strip().length == 0) {
            db_path = "./clanker-saddle.sqlite";
        }
        var db = application.container.configure_with<DatabaseConfigurator>();
        db.register_connection(@"sqlite://$(db_path)");
        db.add_migration<ClankerSaddle.Data.Migrations.M0001_Initial>();
        db.add_entity<Project>(Project.entity_mapping);
        db.add_entity<ProjectLink>(ProjectLink.entity_mapping);
        db.add_entity<TaskEntity>(TaskEntity.entity_mapping);
        db.add_entity<TaskComment>(TaskComment.entity_mapping);
        db.add_entity<TaskBlock>(TaskBlock.entity_mapping);
        db.add_entity<TaskProgress>(TaskProgress.entity_mapping);
        db.add_entity<Saddle>(Saddle.entity_mapping);
        db.add_entity<Session>(Session.entity_mapping);
        db.add_entity<SessionCommand>(SessionCommand.entity_mapping);
        db.add_entity<SaddleEntryDedup>(SaddleEntryDedup.entity_mapping);
        db.add_entity<ApiToken>(ApiToken.entity_mapping);
        db.add_entity<Rule>(Rule.entity_mapping);
        db.add_entity<RuleProject>(RuleProject.entity_mapping);
        db.add_entity<TaskRule>(TaskRule.entity_mapping);
        db.add_entity<ProjectNote>(ProjectNote.entity_mapping);
        db.add_entity<SessionRawLog>(SessionRawLog.entity_mapping);
        db.add_entity<Capability>(Capability.entity_mapping);
        db.add_entity<SaddleCapability>(SaddleCapability.entity_mapping);
        db.add_entity<TaskCapability>(TaskCapability.entity_mapping);
        db.add_entity<PushSubscription>(PushSubscription.entity_mapping);
        db.add_entity<TaskNotifyPref>(TaskNotifyPref.entity_mapping);
        db.add_entity<Goal>(Goal.entity_mapping);
        db.add_entity<GoalLink>(GoalLink.entity_mapping);
        db.add_entity<GoalComment>(GoalComment.entity_mapping);
        db.add_entity<GoalEvent>(GoalEvent.entity_mapping);
        db.migrate_on_startup();

        application.add_scoped<ProjectService>();
        application.add_scoped<TaskService>();
        application.add_scoped<GoalService>();
        application.add_scoped<SaddleService>();
        application.add_scoped<RuleService>();
        application.add_scoped<CapabilityService>();
        application.add_scoped<AllocationService>();
        application.add_scoped<TimelineService>();
        application.add_singleton<SaddlePollState>();
        application.add_singleton<StatePulse>();
        application.add_singleton<PushService>();
        application.add_singleton<Dispatcher>();

        // Web Push (plan 11 task E): the VAPID keypair loads or
        // generates + persists BEFORE the server accepts requests, so
        // every subscriber sees the same public key from the first
        // page render.
        application.container.create_scope()
            .resolve<PushService>().ensure_keys_from_config();

        var statum = application.configure_with<StatumConfigurator>();
        statum.global<ClankerSaddle.Services.PulsePublic>(StatePulse.SLOT_TYPE,
            new ClankerSaddle.Services.PulsePublic());

        // spry:pages-begin
        statum.add_page<HomePage, HomeEntrypoint>();
        statum.add_page<LoginPage, LoginEntrypoint>();
        statum.add_page<ProjectsPage, ProjectsEntrypoint>();
        statum.add_page<ProjectDetailPage, ProjectDetailEntrypoint>();
        statum.add_page<TasksPage, TasksEntrypoint>();
        statum.add_page<TaskDetailPage, TaskDetailEntrypoint>();
        statum.add_page<TaskTerminalPage, TaskTerminalEntrypoint>();
        statum.add_page<GoalsPage, GoalsEntrypoint>();
        statum.add_page<GoalDetailPage, GoalDetailEntrypoint>();
        statum.add_page<SaddlesPage, SaddlesEntrypoint>();
        statum.add_page<RulesPage, RulesEntrypoint>();
        // spry:pages-end

        // spry:actions-begin
        statum.action<LoginAction>();
        statum.action<Spry.Actions.LogoutAction>();
        statum.action<CreateProjectAction>();
        statum.action<UpdateProjectAction>();
        statum.action<AddProjectLinkAction>();
        statum.action<RemoveProjectLinkAction>();
        statum.action<CreateTaskAction>();
        statum.action<UpdateTaskAction>();
        statum.action<AddCommentAction>();
        statum.action<AnswerBlockAction>();
        statum.action<EnqueueTaskAction>();
        statum.action<DeleteTaskAction>();
        statum.action<CancelTaskAction>();
        statum.action<RetryTaskAction>();
        statum.action<ResumeTaskAction>();
        statum.action<RefreshTasksDataAction>();
        statum.action<CreateGoalAction>();
        statum.action<StartGoalAction>();
        statum.action<PauseGoalAction>();
        statum.action<ResumeGoalAction>();
        statum.action<CancelGoalAction>();
        statum.action<RetryGoalRunAction>();
        statum.action<RequeueGoalRunAction>();
        statum.action<GoalCommentAction>();
        statum.action<AnswerGoalBlockAction>();
        statum.action<AddGoalLinkAction>();
        statum.action<RemoveGoalLinkAction>();
        statum.action<RefreshGoalDataAction>();
        statum.action<PushSubscribeAction>();
        statum.action<PushUnsubscribeAction>();
        statum.action<ToggleTaskNotifyAction>();
        statum.action<RefreshTaskDataAction>();
        statum.action<RefreshDashboardAction>();
        statum.action<RegisterSaddleAction>();
        statum.action<UnregisterSaddleAction>();
        statum.action<RefreshSaddleStatusAction>();
        statum.action<UpdateSaddleIdentityAction>();
        statum.action<CreateRuleAction>();
        statum.action<UpdateRuleAction>();
        statum.action<DeleteRuleAction>();
        statum.action<AttachProjectRuleAction>();
        statum.action<DetachProjectRuleAction>();
        statum.action<AttachTaskRuleAction>();
        statum.action<DetachTaskRuleAction>();
        statum.action<DeleteProjectNoteAction>();
        statum.action<CreateCapabilityAction>();
        statum.action<DeleteCapabilityAction>();
        statum.action<AttachSaddleCapabilityAction>();
        statum.action<DetachSaddleCapabilityAction>();
        statum.action<AttachTaskCapabilityAction>();
        statum.action<DetachTaskCapabilityAction>();
        // spry:actions-end

        // spry:resources-begin
        statum.add_resource<ClankerSaddle.AppCss>();
        // spry:resources-end

        // spry:auth-begin
        // spry:auth-end

        application.add_endpoint<SaddleUpdateEndpoint>(
            new EndpointRoute("/api/saddle/{id}/update", Method.POST));
        application.add_endpoint<SaddlePollEndpoint>(
            new EndpointRoute("/api/saddle/{id}/poll", Method.GET));
        application.add_endpoint<SaddleNextTaskEndpoint>(
            new EndpointRoute("/api/saddle/next-task", Method.POST));
        application.add_endpoint<SaddleChunksEndpoint>(
            new EndpointRoute("/api/saddle/chunks", Method.POST));
        application.add_endpoint<SaddleResultsEndpoint>(
            new EndpointRoute("/api/saddle/results", Method.POST));
        application.add_endpoint<SaddleNoteEndpoint>(
            new EndpointRoute("/api/saddle/note", Method.POST));
        application.add_endpoint<SaddleTaskCreateEndpoint>(
            new EndpointRoute("/api/saddle/task/create", Method.POST));
        application.add_endpoint<SaddleTaskDeleteEndpoint>(
            new EndpointRoute("/api/saddle/task/delete", Method.POST));
        application.add_endpoint<SaddleTaskEnqueueEndpoint>(
            new EndpointRoute("/api/saddle/task/enqueue", Method.POST));
        application.add_endpoint<SaddleTaskListEndpoint>(
            new EndpointRoute("/api/saddle/tasks", Method.GET));
        application.add_endpoint<SaddleTaskDetailEndpoint>(
            new EndpointRoute("/api/saddle/task/{id}", Method.GET));
        application.add_endpoint<SaddleCapabilitiesEndpoint>(
            new EndpointRoute("/api/saddle/capabilities", Method.GET));
        application.add_endpoint<ClankerSaddle.Api.TerminalSseEndpoint>(
            new EndpointRoute("/terminal-stream/{session_id}", Method.GET));
        application.add_endpoint<ClankerSaddle.Api.ServiceWorkerEndpoint>(
            new EndpointRoute("/sw.js", Method.GET));

        GLib.Idle.add(() => {
            seed_admin.begin(application.container);
            ensure_saddle_tokens.begin(application.container);
            start_dispatcher.begin(application.container);
            return false;
        });

        application.run();
        return 0;
    } catch (Error e) {
        printerr("Error: %s\n", e.message);
        return 1;
    }
}

/**
 * Seeds the admin account when BOTH SPRY_SEED_ADMIN_USERNAME and
 * SPRY_SEED_ADMIN_PASSWORD are set; skipped silently otherwise. The
 * password is never logged.
 */
private async void seed_admin(Container container) {
    var username = Environment.get_variable("SPRY_SEED_ADMIN_USERNAME") ?? "";
    var password = Environment.get_variable("SPRY_SEED_ADMIN_PASSWORD") ?? "";
    if (username.length == 0 || password.length == 0) {
        return;
    }

    try {
        var scope = container.create_scope();
        yield SpryAuth.ensure_admin(scope.resolve<UserService>(),
            username, @"$(username)@example.com", password);
        print("[ClankerSaddle] Seeded admin account: %s\n", username);
    } catch (Error e) {
        printerr("[ClankerSaddle] Admin seeding failed: %s\n", e.message);
    }
}

private async void start_dispatcher(Container container) {
    try {
        var scope = container.create_scope();
        scope.resolve<Dispatcher>().start();
    } catch (Error e) {
        printerr("[ClankerSaddle] Dispatcher startup failed: %s\n", e.message);
    }
}

/**
 * Startup migration of the per-saddle tokens (plan 10): every saddle
 * row gets its canonical credential — the legacy `api_tokens` value it
 * already holds, or a freshly minted one — so the operator can copy it
 * to daemons registered before the flip (see
 * {@link ClankerSaddle.Services.SaddleService.ensure_saddle_tokens}).
 */
private async void ensure_saddle_tokens(Container container) {
    try {
        var scope = container.create_scope();
        yield scope.resolve<SaddleService>().ensure_saddle_tokens();
    } catch (Error e) {
        printerr("[ClankerSaddle] Saddle token migration failed: %s\n", e.message);
    }
}