css: {
    preprocessorOptions: {
      scss: {
        additionalData(source, fp) {
          if (fp.endsWith('app.scss')) return source;
          return '@import "/src/app.scss";' + source;
        }
      }
    }
  },

      '/recover': {
        target: 'http://127.0.0.1:8001',
        secure: false
      },

import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';

  preprocess: [mdsvex()],

  compilerOptions: {
    runes: true
  },
  preprocess: [
    vitePreprocess({
      script: true,
      style: true
    }),
    mdsvex()
  ],

.hljs-emphasis {
    font-style: italic;
}
.hljs-strong {
    font-weight: 700;
}
@media (prefers-color-scheme: dark) {
    .hljs {
        color: #fff;
        background: #1c1b1b;
    }
    .hljs-subst {
        color: #fff;
    }
    .hljs-comment {
        color: #999;
    }
    .hljs-attr,
    .hljs-doctag,
    .hljs-keyword,
    .hljs-meta .hljs-keyword,
    .hljs-section,
    .hljs-selector-tag {
        color: #88aece;
    }
    .hljs-attribute {
        color: #c59bc1;
    }
    .hljs-name,
    .hljs-number,
    .hljs-quote,
    .hljs-selector-id,
    .hljs-template-tag,
    .hljs-type {
        color: #f08d49;
    }
    .hljs-selector-class {
        color: #88aece;
    }
    .hljs-link,
    .hljs-regexp,
    .hljs-selector-attr,
    .hljs-string,
    .hljs-symbol,
    .hljs-template-variable,
    .hljs-variable {
        color: #b5bd68;
    }
    .hljs-meta,
    .hljs-selector-pseudo {
        color: #88aece;
    }
    .hljs-built_in,
    .hljs-literal,
    .hljs-title {
        color: #f08d49;
    }
    .hljs-bullet,
    .hljs-code {
        color: #ccc;
    }
    .hljs-meta .hljs-string {
        color: #b5bd68;
    }
    .hljs-deletion {
        color: #de7176;
    }
    .hljs-addition {
        color: #76c490;
    }
}
@media (prefers-color-scheme: light) {
    .hljs {
        color: #2f3337;
        background: #f6f6f6;
    }
    .hljs-subst {
        color: #2f3337;
    }
    .hljs-comment {
        color: #656e77;
    }
    .hljs-attr,
    .hljs-doctag,
    .hljs-keyword,
    .hljs-meta .hljs-keyword,
    .hljs-section,
    .hljs-selector-tag {
        color: #015692;
    }
    .hljs-attribute {
        color: #803378;
    }
    .hljs-name,
    .hljs-number,
    .hljs-quote,
    .hljs-selector-id,
    .hljs-template-tag,
    .hljs-type {
        color: #b75501;
    }
    .hljs-selector-class {
        color: #015692;
    }
    .hljs-link,
    .hljs-regexp,
    .hljs-selector-attr,
    .hljs-string,
    .hljs-symbol,
    .hljs-template-variable,
    .hljs-variable {
        color: #54790d;
    }
    .hljs-meta,
    .hljs-selector-pseudo {
        color: #015692;
    }
    .hljs-built_in,
    .hljs-literal,
    .hljs-title {
        color: #b75501;
    }
    .hljs-bullet,
    .hljs-code {
        color: #535a60;
    }
    .hljs-meta .hljs-string {
        color: #54790d;
    }
    .hljs-deletion {
        color: #c02d2e;
    }
    .hljs-addition {
        color: #2f6f44;
    }
}

@import 'tailwindcss';
@plugin "daisyui";
@plugin "@iconify/tailwind4";
@layer base {
}
  h1 {
    font-size: var(--text-2xl) !important;
  }
  h2 {
    font-size: var(--text-xl) !important;
  }
  h3 {
    font-size: var(--text-l) !important;
  }

h3 { font-size: 15pt; }

h3 { font-size: 15pt; }

  export let data: PageData;

  console.log('data', data);

  const { data } = $props();

  let m: any = null;

  let m: any = $state(null);

  export let data: PageData;

  const { data } = $props();

  export let data: PageData;

  console.log('data', data);

  const { data } = $props();

  export let data: null | { code: string };

  const { data }: { data: null | { code: string } } = $props();

import { browser } from '$app/environment';

export const server = import.meta.env.VITE_SERVER

export const server = import.meta.env.VITE_SERVER;

  export let data: PageData;
  const channel = data.channel.length ? data.channel : 'main';

  const { data } = $props();
  const channel = $derived(data.channel.length ? data.channel : 'main');

  <link rel="stylesheet" href="/hljs.css" />

  :global {
    .hljs-emphasis {
      font-style: italic;
    }
    .hljs-strong {
      font-weight: 700;
    }
    @media (prefers-color-scheme: dark) {
      .hljs {
        color: #fff;
        background: #1c1b1b;
      }
      .hljs-subst {
        color: #fff;
      }
      .hljs-comment {
        color: #999;
      }
      .hljs-attr,
      .hljs-doctag,
      .hljs-keyword,
      .hljs-meta .hljs-keyword,
      .hljs-section,
      .hljs-selector-tag {
        color: #88aece;
      }
      .hljs-attribute {
        color: #c59bc1;
      }
      .hljs-name,
      .hljs-number,
      .hljs-quote,
      .hljs-selector-id,
      .hljs-template-tag,
      .hljs-type {
        color: #f08d49;
      }
      .hljs-selector-class {
        color: #88aece;
      }
      .hljs-link,
      .hljs-regexp,
      .hljs-selector-attr,
      .hljs-string,
      .hljs-symbol,
      .hljs-template-variable,
      .hljs-variable {
        color: #b5bd68;
      }
      .hljs-meta,
      .hljs-selector-pseudo {
        color: #88aece;
      }
      .hljs-built_in,
      .hljs-literal,
      .hljs-title {
        color: #f08d49;
      }
      .hljs-bullet,
      .hljs-code {
        color: #ccc;
      }
      .hljs-meta .hljs-string {
        color: #b5bd68;
      }
      .hljs-deletion {
        color: #de7176;
      }
      .hljs-addition {
        color: #76c490;
      }
    }
    @media (prefers-color-scheme: light) {
      .hljs {
        color: #2f3337;
        background: #f6f6f6;
      }
      .hljs-subst {
        color: #2f3337;
      }
      .hljs-comment {
        color: #656e77;
      }
      .hljs-attr,
      .hljs-doctag,
      .hljs-keyword,
      .hljs-meta .hljs-keyword,
      .hljs-section,
      .hljs-selector-tag {
        color: #015692;
      }
      .hljs-attribute {
        color: #803378;
      }
      .hljs-name,
      .hljs-number,
      .hljs-quote,
      .hljs-selector-id,
      .hljs-template-tag,
      .hljs-type {
        color: #b75501;
      }
      .hljs-selector-class {
        color: #015692;
      }
      .hljs-link,
      .hljs-regexp,
      .hljs-selector-attr,
      .hljs-string,
      .hljs-symbol,
      .hljs-template-variable,
      .hljs-variable {
        color: #54790d;
      }
      .hljs-meta,
      .hljs-selector-pseudo {
        color: #015692;
      }
      .hljs-built_in,
      .hljs-literal,
      .hljs-title {
        color: #b75501;
      }
      .hljs-bullet,
      .hljs-code {
        color: #535a60;
      }
      .hljs-meta .hljs-string {
        color: #54790d;
      }
      .hljs-deletion {
        color: #c02d2e;
      }
      .hljs-addition {
        color: #2f6f44;
      }
    }
  }

import type { PageLoad } from './$types';
import { errorMsg, server } from '../../../../helpers';
export const load: PageLoad = async ({ fetch, params }) => {
  const u = `${server}/api/job/${params.user}/${params.repo}/${params.job}`;
  const resp = await fetch(u, { credentials: 'include' });
  if (resp.status == 200) {
    return await resp.json();
  } else {
    const y = await resp.json();
    errorMsg(resp.status, y);
  }
};

<script lang="ts">
  import Nav from '../../Nav.svelte';
  import Tabs from '../../Tabs.svelte';
  import { onMount } from 'svelte';
  import { server } from '../../../../helpers';
  const { data, params } = $props();
  let ended = $derived(data.ended);
  let status = $derived(data.status);
  import { AnsiUp } from 'ansi_up';
  let socket: WebSocket;
  let out: string[][] = $state([[], []]);
  onMount(() => {
    let ansi_up = new AnsiUp();
    socket = new WebSocket(`${server}/api/job/${params.user}/${params.repo}/${params.job}/ws`);
    socket.onmessage = (event) => {
      console.log(event);
      const m = JSON.parse(event.data);
      if ('Chunk' in m) {
        console.log(m);
        out[m.Chunk.channel].push(ansi_up.ansi_to_html(m.Chunk.content));
      } else if ('Status' in m) {
        console.log(m);
        ended = m.Status.ended;
        status = m.Status.status;
      }
    };
    socket.onopen = () => {
      // socket.send('{ "State": { "stdout": 0, "stderr": 0 } }');
    };
  });
</script>
<svelte:head>
  <title>{params.user} / {params.repo}</title>
</svelte:head>
<div class="p-3">
  <Nav user={params.user} repo={params.repo} path={[]} link={true} />
  <Tabs user={params.user} repo={params.repo} channel={data.channel} active="jobs" />
  <h1 class="pt-10">Job {data.id}</h1>
  <div class="py-10">
    Started at {data.started}{#if ended}, ended at {ended} with status {status}{/if}.
  </div>
  <h2 class="mt-5">Stdout</h2>
  <div class="p-5">
    <div class="w-full whitespace-pre-wrap font-mono text-sm">
      {#each out[0] as m}{@html m}{/each}
    </div>
    {#if !out[0].length}
      <p>No stdout so far</p>
    {/if}
  </div>
  <h2 class="mt-10">Stderr</h2>
  <div class="p-5">
    <div class="w-full whitespace-pre-wrap font-mono text-sm">
      {#each out[1] as m}{@html m}{/each}
    </div>
    {#if !out[1].length}
      <p>No stderr so far</p>
    {/if}
  </div>
</div>

import type { PageLoad } from './$types';
import { errorMsg, server } from '../../../helpers';
export const load: PageLoad = async ({ fetch, params }) => {
  const u = `${server}/api/job/${params.user}/${params.repo}`;
  const resp = await fetch(u, { credentials: 'include' });
  if (resp.status == 200) {
    return await resp.json();
  } else {
    const y = await resp.json();
    errorMsg(resp.status, y);
  }
};

<script lang="ts">
  import Nav from '../Nav.svelte';
  import Tabs from '../Tabs.svelte';
  import { resolve } from '$app/paths';
  const { data, params } = $props();
</script>
<svelte:head>
  <title>{data.owner} / {data.repo}</title>
</svelte:head>
<div class="p-3">
  <Nav user={params.user} repo={params.repo} path={[]} link={true} />
  <Tabs
    user={params.user}
    repo={params.repo}
    login={data.user}
    channel={data.channel}
    active="jobs" />
  <div class="p-3">
    <h1 class="mt-5">Jobs</h1>
    <table class="mt-10 table">
      <thead> <tr><td>Job</td><td>Started</td><td>Ended</td><td>Status</td> </tr></thead>
      <tbody>
        {#each data.jobs as job (job.id)}
          <tr>
            <td>
              <a
                class="link link-primary"
                href={resolve('/[user]/[repo]/jobs/[job]', {
                  job: job.id,
                  ...params
                })}>{job.id}</a>
            </td>
            <td>
              {job.started}
            </td>
            <td>
              {job.ended}
            </td>
            <td>
              {job.status}
            </td>
          </tr>
        {/each}
      </tbody>
    </table>
  </div>
</div>

  export let data: {
    owner: string;
    repo: string;
    login: string;
    unique: number;
    token: string;
  };
  console.log('data', data);

  const {
    data
  }: {
    data: {
      owner: string;
      repo: string;
      login: string;
      unique: number;
      token: string;
    };
  } = $props();

  export let data: {
    owner: string;
    repo: string;
    login: string;
    email: string;
    edit_comment?: string;
    d: DiscussionT;
    channels: string[];
    default_channel: string;
    comments: DiscussionItem[];
    uniq: number;
    token: string;
  };

  const {
    data
  }: {
    data: {
      owner: string;
      repo: string;
      login: string;
      email: string;
      edit_comment?: string;
      d: DiscussionT;
      channels: string[];
      default_channel: string;
      comments: DiscussionItem[];
      uniq: number;
      token: string;
    };
  } = $props();

  export let n: number | null = null;
  export let edit = false;
  export let title = '';

  const {
    n,
    edit = false,
    title = ''
  }: {
    n?: number;
    edit: boolean;
    title: string;
  } = $props();

  export let tag: Tag;

  const { tag }: { tag: Tag } = $props();

  export let hash: string;
  export let id: string;
  export let disc: number;
  export let timestamp: number;
  export let pushed_by: string;
  export let removed: number | undefined;
  export let can_add: boolean = false;
  export let can_remove: boolean = false;
  export let owner: string;
  export let repo: string;
  export let token: string;
  export let authors: {
    login?: string;
    name?: string;
    key: string;
  }[] = [];
  export let header:
    | {
        message: string;
        timestamp: string;
      }
    | undefined;
  console.log('HEADER', JSON.stringify(header));

  const {
    hash,
    id,
    disc,
    timestamp,
    pushed_by,
    removed,
    can_add = false,
    can_remove = false,
    owner,
    repo,
    token,
    authors,
    header
  }: {
    hash: string;
    id: string;
    disc: number;
    timestamp: number;
    pushed_by: string;
    removed?: number;
    can_add: boolean;
    can_remove: boolean;
    owner: string;
    repo: string;
    token: string;
    authors: {
      login?: string;
      name?: string;
      key: string;
    }[];
    header?: {
      message: string;
      timestamp: string;
    };
  } = $props();

  import { assets } from '$app/paths';

  // export let author = '';
  // export let id = '';
  export let disc: { closed?: number; n: number } | undefined = undefined;
  // export let timestamp: number;
  // export let value = '';
  // export let value_html = '';
  export let owner: string;
  export let repo: string;
  export let edit: boolean = false;
  export let login: string;
  export let token: string;
  export let uniq: number;

  export let comment: Comment = {
    author: login,
    id: '',
    timestamp: 0,
    content: '',
    content_html: ''
  };

  let {
    disc,
    owner,
    repo,
    edit = false,
    login,
    token,
    uniq,
    comment = {
      author: login,
      id: '',
      timestamp: 0,
      content: '',
      content_html: ''
    }
  }: {
    disc?: { closed?: number; n: number };
    owner: string;
    repo: string;
    edit: boolean;
    login: string;
    token: string;
    uniq: string;
    comment: Comment;
  } = $props();

                on:click={() => (edit = true)}>Edit</button>

                onclick={() => (edit = true)}>Edit</button>

  import type { PageData } from './$types';

  export let data: PageData;
  let includeClosed = false;

  const { data } = $props();
  let includeClosed = $state(false);

          on:change={() => {

          onchange={() => {

  export let c: Position | Vertex;
  export let deps: Deps;

  const { c, deps }: { c: Position | Vertex; deps: Deps } = $props();

  let d: string | null = null;
  if (deps && deps.hashes[c.change]) {
    d = deps.hashes[c.change];
  }

  const d: string | null = $derived.by(() => {
    if (deps && deps.hashes[c.change]) {
      return deps.hashes[c.change];
    } else {
      return null;
    }
  });

  export let m: Meta;
  let dir = (m.metadata & 0x200) != 0 ? 'd' : '-';
  let p =

  const { m }: { m: Meta } = $props();
  const dir = $derived((m.metadata & 0x200) != 0 ? 'd' : '-');
  const p = $derived(

    (m.metadata & 0x80 ? 'w' : '-') +
    (m.metadata & 0x40 ? 'r' : '-') +
    (m.metadata & 0x20 ? 'x' : '-') +
    (m.metadata & 0x10 ? 'w' : '-') +
    (m.metadata & 0x8 ? 'r' : '-') +
    (m.metadata & 0x4 ? 'x' : '-') +
    (m.metadata & 0x2 ? 'w' : '-') +
    (m.metadata & 0x1 ? 'r' : '-');

      (m.metadata & 0x80 ? 'w' : '-') +
      (m.metadata & 0x40 ? 'r' : '-') +
      (m.metadata & 0x20 ? 'x' : '-') +
      (m.metadata & 0x10 ? 'w' : '-') +
      (m.metadata & 0x8 ? 'r' : '-') +
      (m.metadata & 0x4 ? 'x' : '-') +
      (m.metadata & 0x2 ? 'w' : '-') +
      (m.metadata & 0x1 ? 'r' : '-')
  );

  export let flag: Flag;
  let flag_ = bits(flag);

  const { flag }: { flag: Flag } = $props();
  let flag_ = $derived(bits(flag));

  export let edge: Edge;
  export let deps: Deps;

  const { edge, deps }: { deps: Deps; edge: Edge } = $props();

  export let contents: (
    | {
        Add: string;
      }
    | {
        Del: string;
      }
  )[];

  const {
    contents
  }: {
    contents: (
      | {
          Add: string;
        }
      | {
          Del: string;
        }
    )[];
  } = $props();

  export let deps: Deps;
  export let atom: Atom;

  const { deps, atom }: { deps: Deps; atom: Atom } = $props();

  export let data: {
    deps: Deps;
    authors: { login?: string; key: string }[];
    hash: string;
    repo: string;
    owner: string;
    header: {
      message: string;
      timestamp: string;
      description: string | null;

  const {
    data
  }: {
    data: {
      deps: Deps;
      authors: { login?: string; key: string }[];
      hash: string;
      repo: string;
      owner: string;
      header: {
        message: string;
        timestamp: string;
        description: string | null;
      };
      hunks: Hunk[];

    hunks: Hunk[];
  };
  let date = new Intl.DateTimeFormat('en-US', {
    dateStyle: 'medium',
    timeStyle: 'short'
  }).format(new Date(data.header.timestamp));

  } = $props();
  let date = $derived(
    new Intl.DateTimeFormat('en-US', {
      dateStyle: 'medium',
      timeStyle: 'short'
    }).format(new Date(data.header.timestamp))
  );

  import type { PageData } from './$types';

  export let data: PageData;
  const channel = data.channel ? data.channel : 'main';

  const { data } = $props();
  const channel = $derived(data.channel ? data.channel : 'main');

  export let login: string;
  export let owner: string;
  export let repo: string;
  export let perms: number;
  export let everybody: boolean = false;
  export let n: number;
  export let token: string;

  let props: {
    login: string;
    owner: string;
    repo: string;
    perms: number;
    everybody?: boolean;
    n: number;
    token: string;
  } = $props();

<form method="POST" action="/api/admin/{owner}/{repo}/permission">
  <input type="hidden" name="token" value={token} />

<form method="POST" action="/api/admin/{props.owner}/{props.repo}/permission">
  <input type="hidden" name="token" value={props.token} />

        name={everybody ? '' : 'login'}
        value={login}
        disabled={everybody || login == owner} />

        name={props.everybody ? '' : 'login'}
        value={props.login}
        disabled={props.everybody || props.login == props.owner} />

            disabled={login == owner}
            checked={!!(perms & (1 << k))}
            id="{n}-{k}" />
          <label class="label ms-1" for="{n}-{k}"> {label} </label>

            disabled={props.login == props.owner}
            checked={!!(props.perms & (1 << k))}
            id="{props.n}-{k}" />
          <label class="label ms-1" for="{props.n}-{k}"> {label} </label>

      <button class="btn btn-sm btn-secondary" disabled={login == owner}>Ok</button>

      <button class="btn btn-sm btn-secondary" disabled={props.login == props.owner}>Ok</button>

  export let owner: string;
  export let repo: string;
  export let n: null | number = null;
  export let tagColor: number = colors[0];
  export let name = '';
  export let token: string;
  export let id: string | null = null;

  let {
    owner,
    repo,
    n = null,
    tagColor = $bindable(colors[0]),
    name = $bindable(''),
    token,
    id = null
  }: {
    owner: string;
    repo: string;
    n: null | number;
    tagColor: number;
    name: string;
    token: string;
    id: string | null;
  } = $props();

  let nn = n == null ? '' : n;

  let nn = $derived(n == null ? '' : n);

  export let data: PageData;
  let newTagName = '';
  let newTagColor = colors[0];

  const { data } = $props();
  let newTagName = $state('');
  let newTagColor = $state(colors[0]);

<div class="p-3">

<div class="p-3 pb-10">

  import { page } from '$app/state';
  export let user: string;
  export let repo: string;
  export let login: string | undefined = page.data.login;
  export let channel: string | undefined = undefined;
  export let active: 'tree' | 'changes' | 'tags' | 'discussion' | 'ci' | 'admin';

  const {
    user,
    repo,
    login,
    channel,
    active
  }: {
    user: string;
    repo: string;
    login?: string;
    channel?: string;
    active: 'tree' | 'changes' | 'tags' | 'discussion' | 'ci' | 'jobs' | 'admin';
  } = $props();

  <li class="tab{active == 'jobs' ? ' tab-active' : ''}">
    <a href="/{user}/{repo}/jobs"><i class="bi bi-cog"></i> Jobs</a>
  </li>

  export let user = '';
  export let repo = '';
  export let path: { basename: string; pos: string }[] = [];
  export let link = false;

  const {
    user,
    repo,
    path,
    link = false
  }: {
    user: string;
    repo: string;
    path: { basename: string; pos: string }[];
    link: boolean;
  } = $props();

  export let owner: string;
  export let repo: string;
  export let channel: string;
  export let channels: string[];
  export let can_delete: boolean = false;
  export let token: string;
  export let tab: string;

  let {
    owner,
    repo,
    channel = $bindable(),
    channels,
    can_delete = false,
    token,
    tab
  }: {
    owner: string;
    repo: string;
    channel: string;
    channels: string[];
    can_delete: boolean;
    token: string;
    tab: string;
  } = $props();

          on:change={change}

          onchange={change}

  export let data: PageData;

  const { data } = $props();

  import '../app.css';

  import '../app.scss';
  const { children } = $props();

    <slot />

    {@render children()}

@import 'tailwindcss';
@plugin "daisyui";
@plugin "@iconify/tailwind4";
@layer base {
  h1 {
    font-size: var(--text-2xl) !important;
  }
  h2 {
    font-size: var(--text-xl) !important;
  }
  h3 {
    font-size: var(--text-l) !important;
  }
}

        version: 5.5.4(@sveltejs/kit@2.57.1(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))(svelte@5.55.4(@typescript-eslint/types@8.59.0))(typescript@6.0.3)(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))

        version: 5.5.4(@sveltejs/kit@2.57.1(@sveltejs/vite-plugin-svelte@7.0.0(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))(svelte@5.55.4(@typescript-eslint/types@8.59.0))(typescript@6.0.3)(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))
      '@sveltejs/vite-plugin-svelte':
        specifier: ^7.0.0
        version: 7.0.0(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))

        version: 2.57.1(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))(svelte@5.55.4(@typescript-eslint/types@8.59.0))(typescript@6.0.3)(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))

        version: 2.57.1(@sveltejs/vite-plugin-svelte@7.0.0(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))(svelte@5.55.4(@typescript-eslint/types@8.59.0))(typescript@6.0.3)(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))

  '@sveltejs/vite-plugin-svelte-inspector@5.0.2':
    resolution: {integrity: sha512-TZzRTcEtZffICSAoZGkPSl6Etsj2torOVrx6Uw0KpXxrec9Gg6jFWQ60Q3+LmNGfZSxHRCZL7vXVZIWmuV50Ig==}

  '@sveltejs/vite-plugin-svelte@7.0.0':
    resolution: {integrity: sha512-ILXmxC7HAsnkK2eslgPetrqqW1BKSL7LktsFgqzNj83MaivMGZzluWq32m25j2mDOjmSKX7GGWahePhuEs7P/g==}

      '@sveltejs/vite-plugin-svelte': ^6.0.0-next.0
      svelte: ^5.0.0
      vite: ^6.3.0 || ^7.0.0

      svelte: ^5.46.4
      vite: ^8.0.0-beta.7 || ^8.0.0

  '@sveltejs/vite-plugin-svelte@6.2.4':
    resolution: {integrity: sha512-ou/d51QSdTyN26D7h6dSpusAKaZkAiGM55/AKYi+9AGZw7q85hElbjK3kEyzXHhLSnRISHOYzVge6x0jRZ7DXA==}
    engines: {node: ^20.19 || ^22.12 || >=24}
    peerDependencies:
      svelte: ^5.0.0
      vite: ^6.3.0 || ^7.0.0

  '@sveltejs/adapter-node@5.5.4(@sveltejs/kit@2.57.1(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))(svelte@5.55.4(@typescript-eslint/types@8.59.0))(typescript@6.0.3)(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))':

  '@sveltejs/adapter-node@5.5.4(@sveltejs/kit@2.57.1(@sveltejs/vite-plugin-svelte@7.0.0(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))(svelte@5.55.4(@typescript-eslint/types@8.59.0))(typescript@6.0.3)(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))':

      '@sveltejs/kit': 2.57.1(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))(svelte@5.55.4(@typescript-eslint/types@8.59.0))(typescript@6.0.3)(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))

      '@sveltejs/kit': 2.57.1(@sveltejs/vite-plugin-svelte@7.0.0(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))(svelte@5.55.4(@typescript-eslint/types@8.59.0))(typescript@6.0.3)(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))

  '@sveltejs/kit@2.57.1(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))(svelte@5.55.4(@typescript-eslint/types@8.59.0))(typescript@6.0.3)(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))':

  '@sveltejs/kit@2.57.1(@sveltejs/vite-plugin-svelte@7.0.0(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))(svelte@5.55.4(@typescript-eslint/types@8.59.0))(typescript@6.0.3)(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))':

      '@sveltejs/vite-plugin-svelte': 6.2.4(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))

      '@sveltejs/vite-plugin-svelte': 7.0.0(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))

  '@sveltejs/vite-plugin-svelte-inspector@5.0.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))':
    dependencies:
      '@sveltejs/vite-plugin-svelte': 6.2.4(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))
      obug: 2.1.1
      svelte: 5.55.4(@typescript-eslint/types@8.59.0)
      vite: 8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)

  '@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))':

  '@sveltejs/vite-plugin-svelte@7.0.0(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))':

      '@sveltejs/vite-plugin-svelte-inspector': 5.0.2(@sveltejs/vite-plugin-svelte@6.2.4(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6)))(svelte@5.55.4(@typescript-eslint/types@8.59.0))(vite@8.0.10(esbuild@0.27.7)(jiti@2.6.1)(sass@1.77.6))

    "@sveltejs/vite-plugin-svelte": "^7.0.0",

    },
    Eof {
        repo: uuid::Uuid,
        channel: String,

CREATE TABLE jobs(
  id UUID NOT NULL PRIMARY KEY DEFAULT gen_random_uuid(),
  repo UUID NOT NULL REFERENCES repositories(id),
  started TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
  ended TIMESTAMP WITH TIME ZONE,
  status INTEGER
);
UPDATE permissions SET perm = perm | 0x100;
GRANT ALL PRIVILEGES ON jobs TO pijul;

DROP TABLE jobs;

                channels_changed: HashSet::new(),

    pub channels_changed: HashSet<(uuid::Uuid, String)>,

        self,

        mut self,

            }
            for (repo, channel) in self.channels_changed.drain() {
                self.config
                    .replicator
                    .handle_update(
                        None,
                        None,
                        None,
                        ::replication::Update::Eof {
                            repo,
                            channel,
                        },
                    )
                    .await?;

                &chrono::Utc::now(),

                &jiff::Timestamp::now(),

                    sk::expires.eq(key.expires),

                    sk::expires.eq(key.expires.map(jiff_diesel::Timestamp::from)),

        self.channels_changed.insert((id.origin_id(), c.clone()));

use super::RawVertexBuf;
use crate::Config;

use crate::Config;

    debug_handler,

    Json, debug_handler,

    Json,

    Base32, ChannelTxnT, TxnT, TxnTExt,

    Base32, ChannelTxnT, TxnT, TxnTExt,

        } else if txn.channels("")?.is_empty() && (pos.channel.as_deref() == Some("main") || pos.channel.is_none()) {

        } else if txn.channels("")?.is_empty()
            && (pos.channel.as_deref() == Some("main") || pos.channel.is_none())
        {

}
#[derive(Debug)]
struct RawVertexBuf {
    out: Vec<u8>,

use diesel::{
    ExpressionMethods, OptionalExtension, QueryDsl,
};

use diesel::{ExpressionMethods, OptionalExtension, QueryDsl};

pub mod admin;

pub mod admin;

}
#[derive(Debug)]
pub struct RawVertexBuf {
    pub out: Vec<u8>,

        .await.optional()?

        .await
        .optional()?

            Err(crate::Error::Permissions {
                required, got
            })

            Err(crate::Error::Permissions { required, got })

    diesel::dsl::sql::<Bool>("EXISTS (SELECT 1 FROM permissions WHERE permissions.user_id = '00000000-0000-0000-0000-000000000000' AND permissions.repo_id = repositories.id)")

    diesel::dsl::sql::<Bool>(
        "EXISTS (SELECT 1 FROM permissions WHERE permissions.user_id = '00000000-0000-0000-0000-000000000000' AND permissions.repo_id = repositories.id)",
    )

        .get_result::<(
            uuid::Uuid,
            i64,
            String,
            Option<String>,
            i64,
            bool,
            bool,
        )>(db)

        .get_result::<(uuid::Uuid, i64, String, Option<String>, i64, bool, bool)>(db)

        debug!("cache size = {:?}", cache.len());

        trace!("cache size = {:?}", cache.len());

                debug!("cache does not contain {:?} {:?}", change, h);

                trace!("cache does not contain {:?} {:?}", change, h);

use libpijul::pristine::sanakirja::MutTxn;
use libpijul::{ChannelMutTxnT, MutTxnT, MutTxnTExt, TxnT, TxnTExt};

use diesel::{ExpressionMethods, QueryDsl};
use diesel_async::RunQueryDsl;
use libpijul::changestore::ChangeStore;
use libpijul::fs::FsErrorC;
use libpijul::output::{FileError, OutputError};
use libpijul::pristine::sanakirja::MutTxn0;
use libpijul::pristine::sanakirja::SanakirjaError;
use libpijul::pristine::{ForkError, TreeErr, TxnErr};
use libpijul::{
    ApplyError, ArcTxn, ChannelMutTxnT, ChannelRef, MutTxnT, MutTxnTExt, TxnT, TxnTExt,
    UnrecordError,
};
use serde_derive::*;

use tokio::fs::OpenOptions;
use tokio::io::AsyncWriteExt;

    ci: crate::config_file::CiConfig,
    jobs: crate::config::Jobs,

    builders: std::sync::Arc<tokio::sync::Semaphore>,

    pub fn new(locks: RepositoryLocks, db: crate::config::Db) -> Self {
        H { locks, db }

    pub fn new(
        ci: crate::config_file::CiConfig,
        jobs: crate::config::Jobs,
        locks: RepositoryLocks,
        db: crate::config::Db,
        builders: std::sync::Arc<tokio::sync::Semaphore>,
    ) -> Self {
        H {
            ci,
            jobs,
            locks,
            db,
            builders,
        }

use libpijul::pristine::sanakirja::SanakirjaError;
use libpijul::pristine::{ForkError, TxnErr};
use libpijul::{ApplyError, UnrecordError};

    #[error(transparent)]
    Tree(#[from] TreeErr<SanakirjaError>),
    #[error(transparent)]
    File(#[from] FileError<crate::repository::changestore::Error, MutTxn0>),

    Fs(#[from] FsErrorC<crate::repository::changestore::Error, MutTxn0>),
    #[error(transparent)]

    Unrec(#[from] UnrecordError<crate::repository::changestore::Error, MutTxn<()>>),

    Unrec(#[from] UnrecordError<crate::repository::changestore::Error, std::io::Error, MutTxn0>),
    #[error(transparent)]
    Apply(#[from] ApplyError<crate::repository::changestore::Error, MutTxn0>),

    Apply(#[from] ApplyError<crate::repository::changestore::Error, MutTxn<()>>),

    Output(#[from] OutputError<crate::repository::changestore::Error, MutTxn0, std::io::Error>),

    #[error(transparent)]
    Utf8(#[from] std::string::FromUtf8Error),

                        let mut txn = pri.mut_txn_begin()?;
                        let channel = format!("{}_{}", repo, channel);
                        let channel_ = txn.open_or_create_channel(&channel)?;
                        let result =
                            txn.apply_change(&repo_.changes, &mut *channel_.write(), &hash);

                        let txn = pri.arc_txn_begin()?;
                        let channel_ = format!("{}_{}", repo, channel);
                        let mut txn_ = txn.write();
                        let channel_ = txn_.open_or_create_channel(&channel_)?;
                        let mut channel__ = channel_.write();
                        let result = txn_.apply_change(&repo_.changes, &mut *channel__, &hash);

                        txn.touch_channel(&mut *channel_.write(), None);

                        txn_.touch_channel(&mut *channel__, None);
                        std::mem::drop(channel__);
                        std::mem::drop(txn_);

                Update::Eof { repo, channel } => {
                    let repo_ = s.locks.get(&repo).await.unwrap();
                    tokio::task::spawn_blocking(move || {
                        let pri = repo_.pristine.blocking_write();
                        let txn = pri.arc_txn_begin()?;
                        let channel = format!("{}_{}", repo, channel);
                        let channel_ = {
                            let mut txn_ = txn.write();
                            txn_.open_or_create_channel(&channel)?
                        };
                        s.deploy(&txn, &channel_, &repo_.changes, repo)?;
                        Ok::<_, Error>(())
                    });
                }

                        let result = txn.unrecord(&repo_.changes, &mut channel_, &hash, 0);

                        let result = txn.unrecord(
                            &repo_.changes,
                            &mut channel_,
                            &hash,
                            0,
                            &libpijul::working_copy::sink(),
                        );

#[derive(Debug, Deserialize)]
struct Config {
    deployment: Option<String>,
}
fn get_file<C: ChangeStore<Error = crate::repository::changestore::Error>>(
    txn: &ArcTxn<libpijul::pristine::sanakirja::MutTxn0>,
    channel: &ChannelRef<libpijul::pristine::sanakirja::MutTxn0>,
    changes: &C,
    path: &str,
) -> Result<Option<String>, Error> {
    let txn_ = txn.read();
    let channel_ = channel.read();
    let (pos, is_dir) = txn_.follow_oldest_path(changes, &channel, path)?;
    if is_dir {
        return Ok(None);
    }
    let mut out = crate::repository::RawVertexBuf { out: Vec::new() };
    use libpijul::ChannelTxnT;
    let mut graph = libpijul::alive::retrieve(&*txn_, txn_.graph(&*channel_), pos, false)?;
    let mut forward = Vec::new();
    std::mem::drop(channel_);
    std::mem::drop(txn_);
    libpijul::alive::output_graph(changes, &txn, &channel, &mut out, &mut graph, &mut forward)
        .map_err(|x| Error::File(x))?;
    debug!("{:?}", out);
    Ok(Some(String::from_utf8(out.out)?))
}
impl H {
    fn deploy<
        C: ChangeStore<Error = crate::repository::changestore::Error> + Clone + Send + Sync + 'static,
    >(
        &self,
        txn: &ArcTxn<libpijul::pristine::sanakirja::MutTxn0>,
        channel: &ChannelRef<libpijul::pristine::sanakirja::MutTxn0>,
        changes: &C,
        repo: uuid::Uuid,
    ) -> Result<(), Error> {
        if let Some(config) = get_file(txn, channel, changes, "pijul.toml")? {
            debug!("config = {:?}", config);
            if let Ok(parsed) = toml::from_str::<Config>(&config) {
                if let Some(depl) = parsed.deployment {
                    let db = self.db.clone();
                    let txn = txn.clone();
                    let channel = channel.clone();
                    let changes = changes.clone();
                    let jobs = self.jobs.clone();
                    let builders = self.builders.clone();
                    let ci = self.ci.clone();
                    tokio::spawn(async move {
                        let permit = builders.acquire().await.unwrap();
                        use crate::db::jobs::dsl as jobs;
                        let id = diesel::insert_into(jobs::jobs)
                            .values((jobs::repo.eq(repo),))
                            .returning(jobs::id)
                            .get_result::<uuid::Uuid>(&mut db.get().await.unwrap())
                            .await?;
                        let tmp_dir = tempfile::tempdir()?;
                        let wc = libpijul::working_copy::filesystem::FileSystem::from_root(
                            tmp_dir.path(),
                        );
                        tokio::task::spawn_blocking(move || {
                            libpijul::output::output_repository_no_pending(
                                &wc, &changes, &txn, &channel, "", true, None, 1, 0,
                            )?;
                            Ok::<_, Error>(())
                        })
                        .await
                        .unwrap()?;
                        use std::process::Stdio;
                        let (status_tx, status_rx) = tokio::sync::watch::channel(None);
                        let (kill_tx, kill_rx) = tokio::sync::oneshot::channel();
                        let mut cmd = tokio::process::Command::new(tmp_dir.path().join(depl))
                            .current_dir(tmp_dir.path())
                            .stderr(Stdio::piped())
                            .stdout(Stdio::piped())
                            .stdin(Stdio::null())
                            .spawn()?;
                        use tokio::io::AsyncBufReadExt;
                        let stdout = tokio::io::BufReader::new(cmd.stdout.take().unwrap());
                        let mut stdout = stdout.lines();
                        let mut stdout_ok = true;
                        let stderr = tokio::io::BufReader::new(cmd.stderr.take().unwrap());
                        let mut stderr = stderr.lines();
                        jobs.lock()
                            .unwrap()
                            .insert(id, (kill_tx, status_tx.clone(), status_rx));
                        let mut stderr_ok = true;
                        let mut buf_stdout = String::new();
                        let mut last_stdout = std::time::UNIX_EPOCH;
                        let mut buf_stderr = String::new();
                        let mut last_stderr = std::time::UNIX_EPOCH;
                        let bound = std::time::Duration::from_secs(1);
                        let mut files =
                            if let Some(ref path) = ci.filesystem
                            {
                                Some((
                                    OpenOptions::new()
                                        .append(true)
                                        .open(&path.join(&format!("{}.stdout", id)))
                                        .await?,
                                    OpenOptions::new()
                                        .append(true)
                                        .open(&path.join(&format!("{}.stderr", id)))
                                        .await?,
                                ))
                            } else {
                                None
                            };
                        while stdout_ok || stderr_ok {
                            debug!(
                                "stdout || stderr {:?} {:?}",
                                buf_stdout.len(),
                                buf_stderr.len()
                            );
                            tokio::select! {
                                line = stdout.next_line(), if stdout_ok => {
                                    let n = if let Some(line) = line? {
                                        buf_stdout.push_str(&line);
                                        buf_stdout.push('\n');
                                        line.len()
                                    } else {
                                        0
                                    };
                                    if last_stdout.elapsed().unwrap() >= bound  || n == 0 {
                                        debug!("sending stdout to db {:?} {:?}", buf_stdout.len(), buf_stderr.len());
                                        if let Some((ref mut stdout, _)) = files {
                                            stdout.write_all(buf_stdout.as_bytes()).await?;
                                        }
                                        buf_stdout.clear();
                                        debug!("stdout/stderr {:?} {:?}", buf_stdout.len(), buf_stderr.len());
                                        last_stdout = std::time::SystemTime::now();
                                    }
                                    if n == 0 {
                                        stdout_ok = false
                                    }
                                }
                                line = stderr.next_line(), if stderr_ok => {
                                    let n = if let Some(line) = line ?{
                                        buf_stderr.push_str(&line);
                                        buf_stderr.push('\n');
                                        line.len()
                                    } else {
                                        0
                                    };
                                    if last_stderr.elapsed().unwrap() >= bound || n == 0 {
                                        debug!("sending stderr to db {:?}", buf_stderr.len());
                                        if let Some((_, ref mut stderr)) = files {
                                            stderr.write_all(buf_stderr.as_bytes()).await?;
                                        }
                                        buf_stderr.clear();
                                        last_stderr = std::time::SystemTime::now();
                                    }
                                    debug!("{:?}", buf_stderr.len());
                                    if n == 0 {
                                        stderr_ok = false
                                    }
                                }
                            }
                        }
                        let status = tokio::select! {
                            status = cmd.wait() => {
                                status?.code()
                            }
                            _ = kill_rx => {
                                cmd.kill().await?;
                                None
                            }
                        };
                        debug!("process exited with {:?}", status);
                        debug!("stderr {}", buf_stderr);
                        debug!("stdout {}", buf_stdout);
                        let now = chrono::Utc::now();
                        diesel::update(jobs::jobs.find(id))
                            .set((jobs::status.eq(status), jobs::ended.eq(&now)))
                            .execute(&mut db.get().await.unwrap())
                            .await?;
                        status_tx.send(Some((now, status))).unwrap();
                        jobs.lock().unwrap().remove(&id);
                        std::mem::drop(permit);
                        Ok::<_, Error>(())
                    });
                }
            }
        } else {
            debug!("No pijul.toml");
        }
        Ok(())
    }
}

    t: Option<&str>,

    _t: Option<&str>,

        const READ_JOBS = 0x100;
        const WRITE_JOBS = 0x200;

        Perm::READ | Perm::CREATE_DISCUSSION

        Perm::READ | Perm::CREATE_DISCUSSION | Perm::READ_JOBS

    debug_handler,

    Json, Router, debug_handler,

    Json, Router,

mod jobs;

        .allow_origin([
            config_file.origin.parse::<http::HeaderValue>().unwrap(),
        ])

        .allow_origin([config_file.origin.parse::<http::HeaderValue>().unwrap()])

    /*
    let cors = CorsLayer::new()
    .allow_origin(tower_http::cors::AllowOrigin::any());
    */

        let handler = crate::replication::H::new(repo_locks.clone(), config.db.clone());

        let handler = crate::replication::H::new(
            config.ci.clone(),
            config.jobs.clone(),
            repo_locks.clone(),
            config.db.clone(),
            config.builders.clone(),
        );

                    let headers = req.headers();

        use axum::handler::HandlerWithoutStateExt;

async fn logout(State(config): State<Config>, jar: SignedCookieJar) -> (SignedCookieJar, Redirect) {

async fn logout(
    State(_config): State<Config>,
    jar: SignedCookieJar,
) -> (SignedCookieJar, Redirect) {

    let (id, login) = if let Some((id, login)) = get_user_login(&jar, &config).await? {
        (id, Some(login))

    let login = if let Some((_, login)) = get_user_login(&jar, &config).await? {
        Some(login)

        (uuid::Uuid::nil(), None)

        None

        .nest("/job", jobs::router())

            libpijul::pristine::sanakirja::GenericTxn<sanakirja::MutTxn<Arc<sanakirja::Env>, ()>>,

            libpijul::pristine::sanakirja::GenericTxn<sanakirja::MutTxn<Arc<sanakirja::Env>>>,

            std::io::Error,

            libpijul::pristine::sanakirja::GenericTxn<sanakirja::MutTxn<Arc<sanakirja::Env>, ()>>,

            libpijul::pristine::sanakirja::GenericTxn<sanakirja::MutTxn<Arc<sanakirja::Env>>>,

    #[error("Not found")]
    NotFound,

            Error::Forbidden => (StatusCode::FORBIDDEN, "{}").into_response(),
            Error::NotFound => (StatusCode::NOT_FOUND, "{}").into_response(),

use crate::permissions::Perm;
use crate::{Config, get_user_login};
use axum::{
    Router,
    extract::ws::{WebSocket, WebSocketUpgrade},
    extract::{Json, Path, State},
    response::Response,
    routing::{any, get},
};
use axum_extra::extract::SignedCookieJar;
use diesel::{
    BoolExpressionMethods, ExpressionMethods, NullableExpressionMethods, OptionalExtension,
    QueryDsl, Queryable, QueryableByName, Selectable, SelectableHelper,
};
use diesel_async::RunQueryDsl;
use futures::StreamExt;
use inotify::WatchMask;
use serde_derive::*;
use tokio::io::{AsyncReadExt, AsyncSeekExt};
use tracing::*;
pub fn router() -> Router<Config> {
    Router::new()
        .route("/{owner}/{repo}", get(list_jobs))
        .route("/{owner}/{repo}/{job_id}", get(job))
        .route("/{owner}/{repo}/{job_id}/ws", any(ws_handler))
}
#[derive(Debug, Deserialize)]
pub struct JobPath {
    owner: String,
    repo: String,
    job_id: uuid::Uuid,
}
#[derive(Debug, Deserialize)]
pub struct JobsPath {
    owner: String,
    repo: String,
}
#[derive(Debug, Selectable, Queryable, QueryableByName, Serialize)]
#[diesel(check_for_backend(diesel::pg::Pg))]
#[diesel(table_name = crate::db::jobs::dsl)]
struct Job {
    id: uuid::Uuid,
    started: chrono::DateTime<chrono::Utc>,
    ended: Option<chrono::DateTime<chrono::Utc>>,
    status: Option<i32>,
}
#[derive(Debug, Serialize)]
pub struct Jobs {
    login: Option<String>,
    jobs: Vec<Job>,
}
pub async fn list_jobs(
    State(config): State<Config>,
    jar: SignedCookieJar,
    Path(path): Path<JobsPath>,
) -> Result<Json<Jobs>, crate::Error> {
    let (uid, login) = if let Some((a, b)) = get_user_login(&jar, &config).await? {
        (Some(a), Some(b))
    } else {
        (None, None)
    };
    let mut db = config.db.get().await?;
    use crate::db::jobs::dsl as jobs;
    use crate::db::repositories::dsl as repos;
    use crate::db::users::dsl as users;
    Ok(Json(Jobs {
        login,
        jobs: repos::repositories
            .inner_join(jobs::jobs)
            .inner_join(users::users)
            .filter(users::login.eq(path.owner))
            .filter(repos::name.eq(path.repo))
            .filter(repos::owner.nullable().eq(uid).or(crate::has_permissions!(
                uid.unwrap_or(uuid::Uuid::nil()),
                repos::id,
                Perm::READ_JOBS.bits()
            )))
            .select(Job::as_select())
            .order_by(jobs::started.desc())
            .get_results::<Job>(&mut db)
            .await?,
    }))
}
#[derive(Debug, Serialize)]
pub struct Job_ {
    login: Option<String>,
    #[serde(flatten)]
    job: Job,
}
pub async fn job(
    State(config): State<Config>,
    jar: SignedCookieJar,
    Path(path): Path<JobPath>,
) -> Result<Json<Job_>, crate::Error> {
    let (uid, login) = if let Some((a, b)) = get_user_login(&jar, &config).await? {
        (Some(a), Some(b))
    } else {
        (None, None)
    };
    let mut db = config.db.get().await?;
    use crate::db::jobs::dsl as jobs;
    use crate::db::repositories::dsl as repos;
    use crate::db::users::dsl as users;
    if let Some(job) = repos::repositories
        .inner_join(jobs::jobs)
        .inner_join(users::users)
        .filter(users::login.eq(path.owner))
        .filter(repos::name.eq(path.repo))
        .filter(repos::owner.nullable().eq(uid).or(crate::has_permissions!(
            uid.unwrap_or(uuid::Uuid::nil()),
            repos::id,
            Perm::READ_JOBS.bits()
        )))
        .filter(jobs::id.eq(path.job_id))
        .select(Job::as_select())
        .order_by(jobs::started.desc())
        .get_result::<Job>(&mut db)
        .await
        .optional()?
    {
        Ok(Json(Job_ { login, job }))
    } else {
        Err(crate::Error::NotFound)
    }
}
pub async fn ws_handler(
    State(config): State<Config>,
    Path(path): Path<JobPath>,
    ws: WebSocketUpgrade,
) -> Response {
    ws.on_upgrade(move |socket| handle_socket(config, path.job_id, socket))
}
#[derive(Debug, Deserialize, Serialize)]
enum Msg<'a> {
    State {
        stdout: usize,
        stderr: usize,
    },
    Chunk {
        channel: i32,
        offset: usize,
        content: &'a str,
    },
    Status {
        ended: chrono::DateTime<chrono::Utc>,
        status: Option<i32>,
    },
}
async fn handle_socket(config: Config, id: uuid::Uuid, mut socket: WebSocket) {
    let mut remote_stdout = 0;
    let mut remote_stderr = 0;
    let Some(mut status) = config
        .jobs
        .lock()
        .unwrap()
        .get(&id)
        .map(|(_, _, w)| w.clone())
    else {
        debug!("closing");
        if let Some((a, b, c)) = send_all(&config, id, &mut remote_stdout, &mut remote_stderr)
            .await
            .unwrap()
        {
            socket.send(a.into()).await.unwrap_or(());
            socket.send(b.into()).await.unwrap_or(());
            if let Some(c) = c {
                socket.send(c.into()).await.unwrap_or(());
            }
        }
        return;
    };
    let mut status_ok = true;
    let mut notify_buffer = [0; 1024];
    let mut notify = if let Some(ref path) = config.ci.filesystem
    {
        let inotify = inotify::Inotify::init().expect("Error while initializing inotify instance");
        let mut w = inotify.watches();
        w.add(
            &path.join(&format!("{}.stdout", id)),
            WatchMask::MODIFY | WatchMask::CLOSE,
        )
        .unwrap();
        w.add(
            &path.join(&format!("{}.stderr", id)),
            WatchMask::MODIFY | WatchMask::CLOSE,
        )
        .unwrap();
        inotify.into_event_stream(&mut notify_buffer).unwrap()
    } else {
        inotify::Inotify::init()
            .unwrap()
            .into_event_stream(&mut notify_buffer)
            .unwrap()
    };
    let mut stdout = String::new();
    let mut stderr = String::new();
    loop {
        debug!("waiting job");
        tokio::select! {
            _ = notify.next() => {
                if let Some((a, b)) = send_remaining(&config, id, &mut remote_stdout, &mut remote_stderr, &mut stdout, &mut stderr)
                    .await
                    .unwrap()
                {
                    socket.send(a.into()).await.unwrap_or(());
                    socket.send(b.into()).await.unwrap_or(());
                }
            }
            x = status.changed(), if status_ok => {
                debug!("status {:?}", x);
                if x.is_err() {
                    status_ok = false
                }
                let status = status.borrow_and_update().clone();
                debug!("status {:?}", status);
                if let Some((ended, status)) = status {
                    socket.send(serde_json::to_string(&Msg::Status {
                        ended,
                        status
                    }).unwrap().into()).await.unwrap_or(());
                } else {
                    debug!("Nothing to send");
                }
            },
            else => break
        }
    }
}
async fn send_all(
    config: &Config,
    id: uuid::Uuid,
    remote_stdout: &mut usize,
    remote_stderr: &mut usize,
) -> Result<Option<(String, String, Option<String>)>, crate::Error> {
    use crate::db::jobs::dsl as jobs;
    if let Some((ended, status)) = jobs::jobs
        .find(id)
        .select((jobs::ended, jobs::status))
        .get_result::<(Option<chrono::DateTime<chrono::Utc>>, Option<i32>)>(
            &mut config.db.get().await.unwrap(),
        )
        .await
        .optional()
        .unwrap()
    {
        let mut stdout = String::new();
        let mut stderr = String::new();
        debug!("send_all {:?} {:?}", stdout.len(), stderr.len());
        if let Some(ref path) = config.ci.filesystem {
            let mut outf = tokio::fs::File::open(&path.join(&format!("{}.stdout", id))).await?;
            let mut errf = tokio::fs::File::open(&path.join(&format!("{}.stderr", id))).await?;
            outf.seek(std::io::SeekFrom::Start(*remote_stdout as u64))
                .await?;
            errf.seek(std::io::SeekFrom::Start(*remote_stderr as u64))
                .await?;
            outf.read_to_string(&mut stdout).await?;
            errf.read_to_string(&mut stderr).await?;
        }
        *remote_stdout = stdout.len();
        *remote_stderr = stderr.len();
        Ok(Some((
            serde_json::to_string(&Msg::Chunk {
                channel: 0,
                offset: 0,
                content: &stdout,
            })
            .unwrap(),
            serde_json::to_string(&Msg::Chunk {
                channel: 1,
                offset: 0,
                content: &stderr,
            })
            .unwrap(),
            ended.map(|ended| serde_json::to_string(&Msg::Status { ended, status }).unwrap()),
        )))
    } else {
        Ok(None)
    }
}
async fn send_remaining(
    config: &Config,
    id: uuid::Uuid,
    remote_stdout: &mut usize,
    remote_stderr: &mut usize,
    stdout: &mut String,
    stderr: &mut String,
) -> Result<Option<(String, String)>, crate::Error> {
    if let Some(ref path) = config.ci.filesystem {
        let mut outf = tokio::fs::File::open(&path.join(&format!("{}.stdout", id))).await?;
        let mut errf = tokio::fs::File::open(&path.join(&format!("{}.stderr", id))).await?;
        outf.seek(std::io::SeekFrom::Start(*remote_stdout as u64))
            .await?;
        errf.seek(std::io::SeekFrom::Start(*remote_stderr as u64))
            .await?;
        outf.read_to_string(stdout).await?;
        errf.read_to_string(stderr).await?;
        Ok(Some((
            serde_json::to_string(&Msg::Chunk {
                channel: 0,
                offset: 0,
                content: &stdout,
            })
            .unwrap(),
            serde_json::to_string(&Msg::Chunk {
                channel: 1,
                offset: 0,
                content: &stderr,
            })
            .unwrap(),
        )))
    } else {
        Ok(None)
    }
}

use crate::{fallback, get_user_login, get_user_login_email, get_user_login_email_strict, Config};

use crate::repository::TreePath;
use crate::{Config, fallback, get_user_login, get_user_login_email, get_user_login_email_strict};

    debug_handler,

    Form, Json, Router, debug_handler,

    Form, Json, Router,

use axum_extra::TypedHeader;

use axum_extra::TypedHeader;

use diesel_async::AsyncPgConnection;

use diesel_async::AsyncPgConnection;

use crate::repository::TreePath;

use libpijul::Base32;

use libpijul::Base32;

    }
}
diesel::table! {
    use diesel::sql_types::*;
    use diesel::pg::sql_types::*;
    use crate::{Keyalgorithm};
    jobs (id) {
        id -> Uuid,
        repo -> Uuid,
        started -> Timestamptz,
        ended -> Nullable<Timestamptz>,
        status -> Nullable<Int4>,

diesel::joinable!(jobs -> repositories (repo));

    jobs,

use std::path::PathBuf;

}
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
pub struct CiConfig {
    pub filesystem: Option<PathBuf>,

    pub ci: CiConfigFile,

    pub ci: CiConfig,

pub struct CiConfigFile {
    pub port: u16,
    pub key_path: String,
    pub public_key_path: Option<String>,
    pub timeout_secs: u64,
    pub public_keys: Vec<String>,
    pub log_path: String,
    pub tarball_path: String,
}
#[derive(Debug, Default, Serialize, Deserialize)]

    pub builders: std::sync::Arc<tokio::sync::Semaphore>,
    pub ci: crate::config_file::CiConfig,
    pub jobs: Jobs,

pub type Jobs = Arc<
    Mutex<
        HashMap<
            uuid::Uuid,
            (
                tokio::sync::oneshot::Sender<()>,
                tokio::sync::watch::Sender<Option<(chrono::DateTime<chrono::Utc>, Option<i32>)>>,
                tokio::sync::watch::Receiver<Option<(chrono::DateTime<chrono::Utc>, Option<i32>)>>,
            ),
        >,
    >,
>;

        builders: Arc::new(tokio::sync::Semaphore::new(1)),
        ci: config_file.ci.clone(),
        jobs: Arc::new(Mutex::new(HashMap::new())),

    date: chrono::DateTime<chrono::Utc>,

    date: jiff::Timestamp,

    debug_handler,

    Form, debug_handler,

    Form,

    sql_types::Bool, BoolExpressionMethods, ExpressionMethods, OptionalExtension, QueryDsl,

    BoolExpressionMethods, ExpressionMethods, OptionalExtension, QueryDsl, sql_types::Bool,

use rand::{rng, Rng};

use rand::{Rng, rng};

    #[error("This user is inactive. Please contact <a href=\"mailto:support@pijul.org\">support@pijul.org</a> to resolve this situation.")]

    #[error(
        "This user is inactive. Please contact <a href=\"mailto:support@pijul.org\">support@pijul.org</a> to resolve this situation."
    )]

axum = { version = "0.8.7", features = ["macros"] }

axum = { version = "0.8.7", features = ["macros", "ws"] }

inotify = "0.11.1"

jiff = "0.2.16"
jiff-diesel = { version = "0.1.3", features = ["postgres"] }

libpijul = "1.0.0-beta.10"

libc = "0.2.185"
libpijul = "1.0.0-beta.11"

sanakirja = "1.4.3"

sanakirja = "2.0.0-beta"

      };
      "inotify" = rec {
        crateName = "inotify";
        version = "0.11.1";
        edition = "2018";
        sha256 = "16fiffnqhfdwzgrv3wcnaih0a9xbx1a44nma1yn5idr83apkwnxx";
        authors = [
          "Hanno Braun <mail@hannobraun.de>"
          "Félix Saparelli <me@passcod.name>"
          "Cristian Kubis <cristian.kubis@tsunix.de>"
          "Frank Denis <github@pureftpd.org>"
        ];
        dependencies = [
          {
            name = "bitflags";
            packageId = "bitflags 2.10.0";
          }
          {
            name = "futures-core";
            packageId = "futures-core";
            optional = true;
          }
          {
            name = "inotify-sys";
            packageId = "inotify-sys";
          }
          {
            name = "libc";
            packageId = "libc";
          }
          {
            name = "tokio";
            packageId = "tokio";
            optional = true;
            features = [ "net" ];
          }
        ];
        devDependencies = [
          {
            name = "tokio";
            packageId = "tokio";
            features = [ "macros" "rt-multi-thread" "time" ];
          }
        ];
        features = {
          "default" = [ "stream" ];
          "futures-core" = [ "dep:futures-core" ];
          "stream" = [ "futures-core" "tokio" ];
          "tokio" = [ "dep:tokio" ];
        };
        resolvedDefaultFeatures = [ "default" "futures-core" "stream" "tokio" ];
      };
      "inotify-sys" = rec {
        crateName = "inotify-sys";
        version = "0.1.5";
        edition = "2015";
        sha256 = "1syhjgvkram88my04kv03s0zwa66mdwa5v7ddja3pzwvx2sh4p70";
        libName = "inotify_sys";
        authors = [
          "Hanno Braun <hb@hannobraun.de>"
        ];
        dependencies = [
          {
            name = "libc";
            packageId = "libc";
          }
        ];

            name = "inotify";
            packageId = "inotify";
          }
          {

 "base64 0.22.1",

 "sha1",

 "tokio-tungstenite",

dependencies = [
 "serde_core",
]

 "subtle",
 "zeroize",
]
[[package]]
name = "curve25519-dalek"
version = "4.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
dependencies = [
 "cfg-if",
 "cpufeatures",
 "curve25519-dalek-derive",
 "fiat-crypto",
 "rustc_version",

name = "curve25519-dalek-derive"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
dependencies = [
 "proc-macro2",
 "quote",
 "syn 2.0.111",
]
[[package]]

 "curve25519-dalek",

 "curve25519-dalek 3.2.0",

[[package]]
name = "fiat-crypto"
version = "0.2.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"

name = "fs2"
version = "0.4.3"

name = "fs4"
version = "0.6.6"

checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"

checksum = "2eeb4ed9e12f43b7fa0baae3f9cdda28352770132ef2e09a23760c29cae8bd47"

 "libc",
 "winapi",

 "rustix 0.38.44",
 "windows-sys 0.48.0",

name = "imara-diff"
version = "0.1.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "17d34b7d42178945f775e84bc4c36dde7c1c6cdfea656d3354d009056f2bb3d2"
dependencies = [
 "hashbrown 0.15.5",
]
[[package]]

]
[[package]]
name = "inotify"
version = "0.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bd5b3eaf1a28b758ac0faa5a4254e8ab2705605496f1b1f3fbbc3988ad73d199"
dependencies = [
 "bitflags 2.10.0",
 "futures-core",
 "inotify-sys",
 "libc",
 "tokio",

name = "inotify-sys"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb"
dependencies = [
 "libc",
]
[[package]]

 "jiff-tzdb-platform",

 "windows-sys 0.61.2",

name = "jiff-diesel"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3a17d80f23d2a3872a3aaef87c168a6e0442118e55b463ba7f864f82376eeee"
dependencies = [
 "diesel",
 "jiff",
]
[[package]]

]
[[package]]
name = "jiff-tzdb"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c900ef84826f1338a557697dc8fc601df9ca9af4ac137c7fb61d4c6f2dfd3076"
[[package]]
name = "jiff-tzdb-platform"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
dependencies = [
 "jiff-tzdb",

version = "0.2.177"

version = "0.2.185"

checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"

checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f"

version = "1.0.0-beta.10"

version = "1.0.0-beta.11"

checksum = "230807b6b791be169a67d951be0a4c3f1a231281cfc2a8caddec6804e188517a"

checksum = "f625e90234ef1fd164dfe7980ffb04a3036a08e31e051cc29e6273a0c9a7a7e7"

 "bitflags 1.3.2",

 "bitflags 2.10.0",

 "cfg-if",

 "chrono",

 "curve25519-dalek",

 "curve25519-dalek 4.1.3",

 "lazy_static",

 "imara-diff",
 "jiff",

 "memchr",

 "parking_lot 0.11.2",

 "parking_lot 0.12.5",

 "rand 0.8.5",

 "rand 0.9.2",

 "thiserror 1.0.69",
 "toml 0.5.11",

 "thiserror 2.0.17",
 "toml 0.8.23",

version = "0.4.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
[[package]]
name = "linux-raw-sys"

 "inotify",

 "jiff",
 "jiff-diesel",

 "libc",

version = "0.1.5"

version = "0.2.1"

checksum = "498a099351efa4becc6a19c72aa9270598e8fd274ca47052e37455241c88b696"

checksum = "1e91099d4268b0e11973f036e885d652fb0b21fedcf69738c627f94db6a44f42"

version = "0.5.0"

version = "1.0.0-beta.11"

checksum = "c2b3743cd80b65d40b9f20b6575016f76d4221754866316ffbf7d7b0d58e7064"

checksum = "a794a27eb67b7ae7f940c4b94e186a58a525f87d11de1c1a0e317c9b7aafb163"

 "regex",
 "syn 1.0.109",

 "syn 2.0.111",

version = "0.38.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
dependencies = [
 "bitflags 2.10.0",
 "errno",
 "libc",
 "linux-raw-sys 0.4.15",
 "windows-sys 0.52.0",
]
[[package]]
name = "rustix"

 "linux-raw-sys",

 "linux-raw-sys 0.11.0",

version = "1.4.3"

version = "2.0.0-beta"

checksum = "81aaf70d064e2122209f04d01fd91e8908e7a327b516236e1cbc0c3f34ac6d11"

checksum = "4fc53a1e7a19d27c070749c0d2717427d1612c9b100274b205dbb438e605e34a"

 "fs2",

 "fs4",

 "libc",

version = "1.4.1"

version = "2.0.0-beta"

checksum = "8376db34ae3eac6e7bd91168bc638450073b708ce9fb46940de676f552238bf5"

checksum = "48a8500bcb79fe605b1433c30e8c5c078810b24dc4d04ffda35e88d712ff16f0"

]
[[package]]
name = "serde_spanned"
version = "0.6.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
dependencies = [
 "serde",

 "rustix",

 "rustix 1.1.2",

name = "tokio-tungstenite"
version = "0.28.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857"
dependencies = [
 "futures-util",
 "log",
 "tokio",
 "tungstenite",
]
[[package]]

version = "0.5.11"

version = "0.8.23"

checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"

checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"

 "indexmap",

 "serde_spanned 0.6.9",
 "toml_datetime 0.6.11",
 "toml_edit",

 "serde_spanned",
 "toml_datetime",

 "serde_spanned 1.0.3",
 "toml_datetime 0.7.3",

version = "0.6.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
dependencies = [
 "serde",
]
[[package]]
name = "toml_datetime"