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)");
        // SQLite serialisation posture (the flake family where a SELECT
        // stepping against a concurrent write lock — the test harness's
        // fixture writes share this file — returned SQLITE_BUSY, which
        // the ORM's lazy enumerator reports as end-of-rows: an EMPTY
        // result for data that exists): WAL readers never block on (and
        // are never blocked by) writers, and the busy timeout absorbs
        // the remaining writer-writer window.
        try {
            var connection = application.container.create_scope()
                .resolve<InvercargillSql.Connection>();
            connection.execute("PRAGMA journal_mode = WAL");
            connection.execute("PRAGMA busy_timeout = 5000");
        } catch (Error pragma_error) {
            print(@"[ClankerSaddle] sqlite pragmas failed: $(pragma_error.message)\n");
        }
        db.add_migration<ClankerSaddle.Data.Migrations.M0001_Initial>();
        db.add_migration<ClankerSaddle.Data.Migrations.M0002_ForceWake>();
        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<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.migrate_on_startup();

        application.add_scoped<ProjectService>();
        application.add_scoped<TaskService>();
        application.add_scoped<GoalService>();
        application.add_scoped<SaddleService>();
        application.add_scoped<LifecycleService>();
        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>();
        statum.add_page<UsersPage, UsersEntrypoint>();
        statum.add_page<ProfilePage, ProfileEntrypoint>();
        // 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<TaskForceWakeAction>();
        statum.action<RefreshTasksDataAction>();
        statum.action<CreateGoalAction>();
        statum.action<StartGoalAction>();
        statum.action<UpdateDraftGoalAction>();
        statum.action<PauseGoalAction>();
        statum.action<ResumeGoalAction>();
        statum.action<GoalForceWakeAction>();
        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<PushTestAction>();
        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>();
        statum.action<CreateUserAction>();
        statum.action<AlterManagedUserAction>();
        statum.action<SetManagedUserEnabledAction>();
        statum.action<GrantUserAdminAction>();
        statum.action<RevokeUserAdminAction>();
        statum.action<DeleteManagedUserAction>();
        statum.action<ChangeMyPasswordAction>();
        // spry:actions-end

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

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

        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);
            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);
    }
}