Flow view and a live Flow status bar item (0.8.0) 263de209e5ba

// The Flow view (hub spec §13.2 in the editor): each repository's recent

// OxygenFlow runs and their jobs, coloured and turning while they run; a

// job's log streamed into an editor tab; Run pipeline and Re-run; a word when

// a run finishes; and a status bar item for the current bookmark's newest run.

import * as vscode from "vscode";

import type * as api from "./hubapi";

import { HubAuth } from "./auth";

import type { HubRepo } from "./proposals";

import { duration, live, look, newlyFinished, runDescription, runLabel, subject } from "./flowview";

export const LOG_SCHEME = "oxygenhub-flow";

type Node =

  | { kind: "repo"; repo: HubRepo }

  | { kind: "run"; repo: HubRepo; run: api.FlowRun }

  | { kind: "job"; repo: HubRepo; run: api.FlowRun; job: api.FlowJob };

export type RunNode = Extract<Node, { kind: "run" }>;

export type JobNode = Extract<Node, { kind: "job" }>;

const RUNS = 15;

function icon(status: string): vscode.ThemeIcon {

  const l = look(status);

  return new vscode.ThemeIcon(l.icon, new vscode.ThemeColor(l.color));

}

function key(repo: HubRepo, run: api.FlowRun): string {

  return `${repo.base}/${repo.owner}/${repo.name}#${run.number}`;

}

export class FlowProvider implements vscode.TreeDataProvider<Node>, vscode.Disposable {

  private readonly emitter = new vscode.EventEmitter<Node | void>();

  readonly onDidChangeTreeData = this.emitter.event;

  /** Runs by repository, newest first, as last fetched. */

  private runs = new Map<string, { repo: HubRepo; runs: api.FlowRun[] }>();

  /** Every run's status at the last look, to notice runs that finish. */

  private seen = new Map<string, string>();

  private timer: NodeJS.Timeout | undefined;

  private readonly bar: vscode.StatusBarItem;

  private readonly disposables: vscode.Disposable[] = [];

  constructor(

    private readonly repos: () => Promise<HubRepo[]>,

    private readonly auth: HubAuth,

  ) {

    this.bar = vscode.window.createStatusBarItem("oxygenhub.flow", vscode.StatusBarAlignment.Left, 98);

    this.bar.name = "OxygenFlow";

    this.disposables.push(this.bar, vscode.window.onDidChangeActiveTextEditor(() => this.updateBar()));

  }

  dispose(): void {

    if (this.timer) {

      clearTimeout(this.timer);

    }

    this.disposables.forEach((d) => d.dispose());

  }

  /** Fetch every repository's runs again, redraw, and keep polling while any is live. */

  async refresh(): Promise<void> {

    const repos = await this.repos().catch(() => [] as HubRepo[]);

    const next = new Map<string, { repo: HubRepo; runs: api.FlowRun[] }>();

    await Promise.all(

      repos.map(async (repo) => {

        const runs = await this.auth.clientFor(repo.base).flowRuns(repo.owner, repo.name, RUNS).catch(() => [] as api.FlowRun[]);

        next.set(`${repo.base}/${repo.owner}/${repo.name}`, { repo, runs });

      }),

    );

    const all = [...next.values()].flatMap(({ repo, runs }) => runs.map((run) => ({ key: key(repo, run), repo, run })));

    const firstLook = this.seen.size === 0;

    for (const done of newlyFinished(this.seen, all)) {

      const found = all.find((a) => a.key === done.key);

      if (found && !firstLook) {

        void this.announce(found.repo, found.run);

      }

    }

    this.seen = new Map(all.map((a) => [a.key, a.run.status]));

    this.runs = next;

    this.emitter.fire();

    this.updateBar();

    if (this.timer) {

      clearTimeout(this.timer);

    }

    const anyLive = all.some((a) => live(a.run.status));

    const every = vscode.workspace.getConfiguration("oxygenhub").get<number>("flowPollSeconds", 5);

    this.timer = setTimeout(() => void this.refresh(), (anyLive ? every : Math.max(every, 60)) * 1000);

  }

  /** A run finished: say so, with the way to its log when it failed. */

  private async announce(repo: HubRepo, run: api.FlowRun): Promise<void> {

    if (!vscode.workspace.getConfiguration("oxygenhub").get<boolean>("flowNotifications", true)) {

      return;

    }

    const full = await this.auth.clientFor(repo.base).flowRun(repo.owner, repo.name, run.number).catch(() => run);

    const text = `OxygenFlow run #${run.number} on ${subject(run)} (${repo.name}) ${look(run.status).word}`;

    if (run.status === "passed") {

      const pick = await vscode.window.showInformationMessage(`✔ ${text}.`, "Open Run");

      if (pick) {

        void vscode.env.openExternal(vscode.Uri.parse(run.url));

      }

      return;

    }

    const failed = (full.jobs ?? []).find((j) => j.status === "failed" || j.status === "error");

    const pick = await vscode.window.showErrorMessage(`✘ ${text}${failed ? `: ${failed.name}` : ""}.`, ...(failed ? ["Show Log"] : []), "Open Run");

    if (pick === "Show Log" && failed) {

      void openLog(repo, full, failed);

    } else if (pick === "Open Run") {

      void vscode.env.openExternal(vscode.Uri.parse(run.url));

    }

  }

  /** The status bar: the newest run of the active repository's current bookmark. */

  private updateBar(): void {

    const file = vscode.window.activeTextEditor?.document.uri.fsPath;

    const entries = [...this.runs.values()];

    const entry = entries.find((e) => file && file.startsWith(e.repo.handle.root)) ?? (entries.length === 1 ? entries[0] : undefined);

    const bookmark = entry?.repo.handle.currentBookmark;

    const run = entry?.runs.find((r) => r.bookmark === bookmark) ?? undefined;

    if (!entry || !run) {

      this.bar.hide();

      return;

    }

    const l = look(run.status);

    this.bar.text = `$(${l.icon}) Flow #${run.number}`;

    this.bar.tooltip = new vscode.MarkdownString(`**OxygenFlow** run #${run.number} on \`${subject(run)}\`\n\n${runDescription(run)}\n\nClick for recent runs.`);

    this.bar.backgroundColor = run.status === "failed" || run.status === "error" ? new vscode.ThemeColor("statusBarItem.errorBackground") : undefined;

    this.bar.color = run.status === "passed" ? new vscode.ThemeColor("testing.iconPassed") : undefined;

    this.bar.command = { title: "Recent runs", command: "oxygenhub.flowRecent", arguments: [entry.repo] };

    this.bar.show();

  }

  /** Recent runs of a repository to pick from; the pick opens on the hub or shows its failed job's log. */

  async recent(repo?: HubRepo): Promise<void> {

    const entry = repo ? this.runs.get(`${repo.base}/${repo.owner}/${repo.name}`) : [...this.runs.values()][0];

    if (!entry) {

      return;

    }

    type Item = vscode.QuickPickItem & { run: api.FlowRun };

    const items: Item[] = entry.runs.map((run) => ({ label: `$(${look(run.status).icon}) ${runLabel(run)}`, description: runDescription(run), run }));

    const pick = await vscode.window.showQuickPick(items, { placeHolder: `OxygenFlow runs of ${entry.repo.owner}/${entry.repo.name}` });

    if (pick) {

      void vscode.env.openExternal(vscode.Uri.parse(pick.run.url));

    }

  }

  getTreeItem(node: Node): vscode.TreeItem {

    switch (node.kind) {

      case "repo": {

        const item = new vscode.TreeItem(`${node.repo.owner}/${node.repo.name}`, vscode.TreeItemCollapsibleState.Expanded);

        item.iconPath = new vscode.ThemeIcon("repo");

        item.contextValue = "flowRepo";

        return item;

      }

      case "run": {

        const run = node.run;

        const item = new vscode.TreeItem(runLabel(run), live(run.status) ? vscode.TreeItemCollapsibleState.Expanded : vscode.TreeItemCollapsibleState.Collapsed);

        item.id = `${key(node.repo, run)}@${run.status}`;

        item.description = runDescription(run);

        item.iconPath = icon(run.status);

        item.tooltip = new vscode.MarkdownString(`**Run #${run.number}** on \`${subject(run)}\` — ${look(run.status).word}\n\n${runDescription(run)}${run.error ? `\n\n\`\`\`\n${run.error}\n\`\`\`` : ""}`);

        item.contextValue = live(run.status) ? "flowRunLive" : "flowRun";

        item.accessibilityInformation = { label: `Run ${run.number} on ${subject(run)}, ${look(run.status).word}` };

        return item;

      }

      case "job": {

        const j = node.job;

        const item = new vscode.TreeItem(j.name, vscode.TreeItemCollapsibleState.None);

        const took = j.started_ms ? duration((j.finished_ms ?? Date.now()) - j.started_ms) : "";

        item.description = [look(j.status).word, took, j.runner ? `on ${j.runner}` : ""].filter(Boolean).join(" · ");

        item.iconPath = icon(j.status);

        item.contextValue = "flowJob";

        item.command = { title: "Show Log", command: "oxygenhub.flowLog", arguments: [node] };

        item.tooltip = j.error ? new vscode.MarkdownString(`**${j.name}**: ${j.error}`) : `${j.name} — ${look(j.status).word}; click for its log`;

        return item;

      }

    }

  }

  async getChildren(node?: Node): Promise<Node[]> {

    if (!node) {

      if (this.runs.size === 0) {

        await this.refresh();

      }

      return [...this.runs.values()].map(({ repo }) => ({ kind: "repo" as const, repo }));

    }

    if (node.kind === "repo") {

      const entry = this.runs.get(`${node.repo.base}/${node.repo.owner}/${node.repo.name}`);

      return (entry?.runs ?? []).map((run) => ({ kind: "run" as const, repo: node.repo, run }));

    }

    if (node.kind === "run") {

      const full = await this.auth.clientFor(node.repo.base).flowRun(node.repo.owner, node.repo.name, node.run.number).catch(() => node.run);

      return (full.jobs ?? []).map((job) => ({ kind: "job" as const, repo: node.repo, run: full, job }));

    }

    return [];

  }

  /** Run pipeline: a bookmark's current state (the current one first) or one change. */

  async start(repo?: HubRepo): Promise<void> {

    const repos = repo ? [repo] : [...this.runs.values()].map((e) => e.repo);

    const target =

      repos.length === 1

        ? repos[0]

        : (await vscode.window.showQuickPick(repos.map((r) => ({ label: `${r.owner}/${r.name}`, r })), { placeHolder: "Run the pipeline of" }))?.r;

    if (!target) {

      return;

    }

    const current = target.handle.currentBookmark;

    const names = [...new Set([current, ...target.handle.bookmarks.map((b) => b.name)].filter((b): b is string => !!b))];

    const pick = await vscode.window.showQuickPick(

      [...names.map((n) => ({ label: `$(bookmark) ${n}`, description: n === current ? "current" : "", bookmark: n })), { label: "$(git-commit) A change…", description: "run one change's own state", bookmark: "" }],

      { placeHolder: `Run the pipeline of ${target.owner}/${target.name} on` },

    );

    if (!pick) {

      return;

    }

    let body: { bookmark?: string; change?: string } = { bookmark: pick.bookmark };

    if (!pick.bookmark) {

      const change = await vscode.window.showInputBox({ prompt: "The change's full hash", validateInput: (v) => (/^#?[0-9a-f]{64}$/.test(v.trim()) ? undefined : "64 hex digits") });

      if (!change) {

        return;

      }

      body = { change: change.trim().replace(/^#/, "") };

    }

    try {

      const started = await this.auth.clientFor(target.base).startFlowRun(target.owner, target.name, body);

      vscode.window.setStatusBarMessage(`$(play) OxygenFlow run #${started.number} started`, 4000);

      await this.refresh();

    } catch (e) {

      vscode.window.showErrorMessage(`OxygenFlow: ${(e as Error).message}`);

    }

  }

  async rerun(node: RunNode): Promise<void> {

    try {

      const started = await this.auth.clientFor(node.repo.base).rerunFlowRun(node.repo.owner, node.repo.name, node.run.number);

      vscode.window.setStatusBarMessage(`$(debug-rerun) OxygenFlow run #${started.number} started`, 4000);

      await this.refresh();

    } catch (e) {

      vscode.window.showErrorMessage(`OxygenFlow: ${(e as Error).message}`);

    }

  }

}

/** Streamed job logs, as read-only documents that grow while the job runs. */

export class FlowLogs implements vscode.TextDocumentContentProvider, vscode.Disposable {

  private readonly emitter = new vscode.EventEmitter<vscode.Uri>();

  readonly onDidChange = this.emitter.event;

  private readonly logs = new Map<string, { text: string; after: number; timer?: NodeJS.Timeout }>();

  constructor(private readonly auth: HubAuth) {}

  dispose(): void {

    for (const l of this.logs.values()) {

      if (l.timer) {

        clearTimeout(l.timer);

      }

    }

  }

  provideTextDocumentContent(uri: vscode.Uri): string {

    return this.logs.get(uri.toString())?.text ?? "Loading…\n";

  }

  /** Start (or keep) following a job's log at `uri`. */

  follow(uri: vscode.Uri, repo: HubRepo, run: number, job: string): void {

    if (this.logs.has(uri.toString())) {

      return;

    }

    const entry = { text: "", after: 0, timer: undefined as NodeJS.Timeout | undefined };

    this.logs.set(uri.toString(), entry);

    const client = this.auth.clientFor(repo.base);

    const tick = async (): Promise<void> => {

      try {

        const lines = await client.flowLog(repo.owner, repo.name, run, job, entry.after);

        if (lines.length) {

          entry.text += lines.map((l) => (l.stream === "flow" ? `▸ ${l.text}` : l.text)).join("\n") + "\n";

          entry.after = lines[lines.length - 1].seq;

          this.emitter.fire(uri);

        }

        const r = await client.flowRun(repo.owner, repo.name, run);

        const j = (r.jobs ?? []).find((x) => x.name === job);

        if (j && live(j.status)) {

          entry.timer = setTimeout(() => void tick(), 2000);

        } else if (j) {

          entry.text += `\n── ${job}: ${look(j.status).word}${j.exit_code !== null && j.exit_code !== undefined ? ` (exit ${j.exit_code})` : ""}${j.error ? `: ${j.error}` : ""} ──\n`;

          this.emitter.fire(uri);

        }

      } catch (e) {

        entry.text += `\n(could not read the log: ${(e as Error).message})\n`;

        this.emitter.fire(uri);

      }

    };

    void tick();

  }

}

let logs: FlowLogs | undefined;

export function useLogs(l: FlowLogs): void {

  logs = l;

}

/** Open a job's log in an editor tab, following it while the job runs. */

export async function openLog(repo: HubRepo, run: api.FlowRun, job: api.FlowJob): Promise<void> {

  const uri = vscode.Uri.from({ scheme: LOG_SCHEME, path: `/${repo.owner}/${repo.name}/run-${run.number}/${job.name}.log`, query: repo.base });

  logs?.follow(uri, repo, run.number, job.name);

  const doc = await vscode.workspace.openTextDocument(uri);

  await vscode.languages.setTextDocumentLanguage(doc, "log");

  await vscode.window.showTextDocument(doc, { preview: false });

}

// OxygenFlow in the editor, without VS Code: how runs and jobs look (icon,

// colour, labels) and which runs just finished. Shared by the Flow view, the

// status bar item and the tests.

import type { FlowRun } from "./hubapi";

/** A codicon and a theme colour id for a run's or job's status. */

export interface Look {

  /** Codicon id; `~spin` makes it turn. */

  icon: string;

  /** A theme colour id, e.g. `testing.iconPassed`. */

  color: string;

  /** A short word for screen readers and tooltips. */

  word: string;

}

export function look(status: string): Look {

  switch (status) {

    case "passed":

      return { icon: "pass-filled", color: "testing.iconPassed", word: "passed" };

    case "failed":

      return { icon: "error", color: "testing.iconFailed", word: "failed" };

    case "error":

      return { icon: "warning", color: "testing.iconErrored", word: "could not run" };

    case "running":

      return { icon: "sync~spin", color: "oxygenhub.flowRunning", word: "running" };

    case "queued":

      return { icon: "clock", color: "testing.iconQueued", word: "queued" };

    case "skipped":

      return { icon: "debug-step-over", color: "testing.iconSkipped", word: "skipped" };

    default:

      return { icon: "circle-large-outline", color: "descriptionForeground", word: status };

  }

}

export function live(status: string): boolean {

  return status === "queued" || status === "running";

}

/** "3.2 s", "4 min 10 s". */

export function duration(ms: number): string {

  const s = Math.max(0, ms) / 1000;

  if (s < 60) {

    return `${s.toFixed(1)} s`;

  }

  return `${Math.floor(s / 60)} min ${Math.floor(s % 60)} s`;

}

/** "just now", "5 minutes ago", as the hub says it. */

export function ago(ms: number, now = Date.now()): string {

  const s = Math.max(0, Math.floor((now - ms) / 1000));

  const unit = (n: number, w: string) => `${n} ${w}${n === 1 ? "" : "s"} ago`;

  if (s < 45) {

    return "just now";

  }

  if (s < 90) {

    return "a minute ago";

  }

  if (s < 2700) {

    return unit(Math.ceil(s / 60), "minute");

  }

  if (s < 5400) {

    return "an hour ago";

  }

  if (s < 79200) {

    return unit(Math.ceil(s / 3600), "hour");

  }

  return unit(Math.ceil(s / 86400), "day");

}

/** What a run ran on: its bookmark, or the change for a run on one change. */

export function subject(run: FlowRun): string {

  return run.bookmark || `change ${(run.heads[0] ?? "").slice(0, 12)}`;

}

/** "#12 main". */

export function runLabel(run: FlowRun): string {

  return `#${run.number} ${subject(run)}`;

}

/** "passed in 2 min 3 s · push by andy · 5 minutes ago". */

export function runDescription(run: FlowRun, now = Date.now()): string {

  const took = run.finished_ms ? ` in ${duration(run.finished_ms - run.created_ms)}` : "";

  const queued = run.status === "queued" && run.queue_position ? ` (#${run.queue_position} in line)` : "";

  const trigger = run.trigger.startsWith("rerun:") ? `re-run of #${run.trigger.slice(6)}` : run.trigger;

  return `${look(run.status).word}${took}${queued} · ${trigger} by ${run.actor} · ${ago(run.created_ms, now)}`;

}

/**

 * Runs that were live at the last look and are finished now, so the editor

 * can say so once. `before` maps a run's key to its last status.

 */

export function newlyFinished(before: Map<string, string>, runs: { key: string; run: FlowRun }[]): { key: string; run: FlowRun }[] {

  return runs.filter(({ key, run }) => {

    const was = before.get(key);

    return was !== undefined && live(was) && !live(run.status);

  });

}

import { test } from "node:test";

import assert from "node:assert/strict";

import { ago, duration, live, look, newlyFinished, runDescription, runLabel } from "../out/flowview.mjs";

const run = (over = {}) => ({ number: 12, bookmark: "main", heads: ["a".repeat(64)], status: "passed", trigger: "push", actor: "andy", created_ms: 1_000_000, finished_ms: 1_125_000, url: "", state: "", pipeline_hash: "", error: "", ...over });

test("statuses look the part", () => {

  assert.equal(look("running").icon, "sync~spin", "running turns");

  assert.equal(look("passed").color, "testing.iconPassed");

  assert.equal(look("failed").icon, "error");

  assert.equal(look("queued").word, "queued");

  assert.ok(live("queued") && live("running") && !live("passed"));

});

test("runs are labelled and described", () => {

  assert.equal(runLabel(run()), "#12 main");

  assert.equal(runLabel(run({ bookmark: "" })), `#12 change ${"a".repeat(12)}`);

  assert.equal(runDescription(run(), 1_125_000 + 10_000), "passed in 2 min 5 s · push by andy · 3 minutes ago");

  assert.match(runDescription(run({ status: "queued", finished_ms: null, queue_position: 3, trigger: "rerun:9" }), 1_000_000), /^queued \(#3 in line\) · re-run of #9 by andy · just now$/);

  assert.equal(duration(3200), "3.2 s");

  assert.equal(ago(0, 7_200_000), "2 hours ago");

});

test("a run is announced once, when it stops being live", () => {

  const before = new Map([["a#1", "running"], ["a#2", "passed"], ["a#3", "queued"]]);

  const now = [

    { key: "a#1", run: run({ status: "failed" }) },

    { key: "a#2", run: run({ status: "passed" }) },

    { key: "a#3", run: run({ status: "running" }) },

    { key: "a#4", run: run({ status: "passed" }) },

  ];

  assert.deepEqual(newlyFinished(before, now).map((x) => x.key), ["a#1"], "only the one that finished; new runs are not news");

});

## 0.8.0 (2026-09-29)

- **Flow view.** The OxygenHub sidebar shows each repository's recent OxygenFlow runs and their jobs.

  - A running run or job turns, and each status has its own colour: passed, failed, queued, skipped and could not run. Running uses the new themeable colour `oxygenhub.flowRunning`.

  - Click a job to open its log in an editor tab. The log grows while the job runs and ends with the job's result.

  - **Run Pipeline…** runs a bookmark's current state (the current bookmark first) or one change, without a push. **Re-run** repeats a finished run. **Open Run on OxygenHub** opens the run's page.

  - When a run you can see finishes, a notification says so, with **Show Log** for a failed job (`oxygenhub.flowNotifications`).

  - It looks again every 5 seconds while something runs, and once a minute otherwise (`oxygenhub.flowPollSeconds`).

- **Flow in the status bar.** The newest run of the current bookmark shows as `Flow #N`. It turns while it runs, shows green when it passes and red when it fails. Click it for recent runs.

| `oxygenhub.flowPollSeconds` | `5` | How often the Flow view and its status bar item look again while a run is queued or running; once a minute otherwise. |

| `oxygenhub.flowNotifications` | `true` | Say when an OxygenFlow run finishes, with a way to a failed job's log. |

  "version": "0.8.0",

        },

        "oxygenhub.flowPollSeconds": {

          "type": "number",

          "default": 5,

          "minimum": 2,

          "description": "How often the Flow view and status bar look again while a run is queued or running (seconds); once a minute otherwise."

        },

        "oxygenhub.flowNotifications": {

          "type": "boolean",

          "default": true,

          "description": "Say when an OxygenFlow run you can see finishes, with a way to its failed job's log."

        },

        {

          "id": "oxygenhub.flow",

          "name": "Flow"

      },

      {

        "view": "oxygenhub.flow",

        "contents": "OxygenFlow runs of your hub repositories appear here: a push that moves a bookmark starts one.\n[Run Pipeline](command:oxygenhub.runPipeline)"

      },

      {

        "command": "oxygenhub.flowRefresh",

        "title": "Refresh Flow",

        "category": "OxygenHub",

        "icon": "$(refresh)"

      },

      {

        "command": "oxygenhub.runPipeline",

        "title": "Run Pipeline\u2026",

        "category": "OxygenHub",

        "icon": "$(play)"

      },

      {

        "command": "oxygenhub.rerunFlow",

        "title": "Re-run",

        "category": "OxygenHub",

        "icon": "$(debug-rerun)"

      },

      {

        "command": "oxygenhub.flowLog",

        "title": "Show Job Log",

        "category": "OxygenHub",

        "icon": "$(output)"

      },

      {

        "command": "oxygenhub.openFlowRun",

        "title": "Open Run on OxygenHub",

        "category": "OxygenHub",

        "icon": "$(link-external)"

      },

      {

        "command": "oxygenhub.flowRecent",

        "title": "Recent Flow Runs\u2026",

        "category": "OxygenHub"

        },

        {

          "command": "oxygenhub.runPipeline",

          "when": "view == oxygenhub.flow",

          "group": "navigation@1"

        },

        {

          "command": "oxygenhub.flowRefresh",

          "when": "view == oxygenhub.flow",

          "group": "navigation@2"

          "group": "inline"

        },

        {

          "command": "oxygenhub.runPipeline",

          "when": "view == oxygenhub.flow && viewItem == flowRepo",

          "group": "inline"

        },

        {

          "command": "oxygenhub.rerunFlow",

          "when": "view == oxygenhub.flow && viewItem == flowRun",

          "group": "inline@1"

        },

        {

          "command": "oxygenhub.openFlowRun",

          "when": "view == oxygenhub.flow && viewItem =~ /^flowRun/",

          "group": "inline@2"

        },

        {

          "command": "oxygenhub.flowLog",

          "when": "view == oxygenhub.flow && viewItem == flowJob",

        },

        {

          "command": "oxygenhub.rerunFlow",

          "when": "false"

        },

        {

          "command": "oxygenhub.flowLog",

          "when": "false"

        },

        {

          "command": "oxygenhub.openFlowRun",

          "when": "false"

    },

    "colors": [

      {

        "id": "oxygenhub.flowRunning",

        "description": "OxygenFlow: the icon of a run or job that is running.",

        "defaults": {

          "dark": "#35c7ff",

          "light": "#0a74b8",

          "highContrast": "#35c7ff",

          "highContrastLight": "#0a5a8f"

        }

      }

    ]

    "pretest": "esbuild src/hub.ts --bundle --platform=node --format=esm --outfile=out/hub.mjs && esbuild src/provider.ts --bundle --platform=node --format=esm --outfile=out/provider.mjs && esbuild src/refs.ts --bundle --platform=node --format=esm --outfile=out/refs.mjs && esbuild src/flowview.ts --bundle --platform=node --format=esm --outfile=out/flowview.mjs",

import { FlowLogs, FlowProvider, JobNode, LOG_SCHEME, RunNode, openLog, useLogs } from "./flow";

let flow: FlowProvider;

  flow = new FlowProvider(() => proposals.repos(), auth);

  const flowLogs = new FlowLogs(auth);

  useLogs(flowLogs);

  context.subscriptions.push(

    flow,

    flowLogs,

    vscode.window.registerTreeDataProvider("oxygenhub.flow", flow),

    vscode.workspace.registerTextDocumentContentProvider(LOG_SCHEME, flowLogs),

    vscode.commands.registerCommand("oxygenhub.flowRefresh", () => flow.refresh()),

    vscode.commands.registerCommand("oxygenhub.runPipeline", (node?: { repo?: HubRepo }) => flow.start(node?.repo)),

    vscode.commands.registerCommand("oxygenhub.rerunFlow", (node: RunNode) => flow.rerun(node)),

    vscode.commands.registerCommand("oxygenhub.flowLog", (node: JobNode) => openLog(node.repo, node.run, node.job)),

    vscode.commands.registerCommand("oxygenhub.openFlowRun", (node: RunNode) => vscode.env.openExternal(vscode.Uri.parse(node.run.url))),

    vscode.commands.registerCommand("oxygenhub.flowRecent", (repo?: HubRepo) => flow.recent(repo)),

  );

  void flow.refresh();

  /** Recent OxygenFlow runs, newest first. */

  flowRuns(owner: string, name: string, limit = 15): Promise<api.FlowRun[]> {

    return this.request("GET", `/repos/${owner}/${name}/flow/runs?limit=${limit}`);

  }

  /** A run with its jobs. */

  flowRun(owner: string, name: string, number: number): Promise<api.FlowRun> {

    return this.request("GET", `/repos/${owner}/${name}/flow/runs/${number}`);

  }

  /** A job's log lines after `after` (a line's seq). */

  flowLog(owner: string, name: string, number: number, job: string, after = 0): Promise<api.FlowLogLine[]> {

    return this.request("GET", `/repos/${owner}/${name}/flow/runs/${number}/jobs/${encodeURIComponent(job)}/log?after=${after}&limit=2000`);

  }

  /** Run the pipeline of a bookmark's current state, or of one change. */

  startFlowRun(owner: string, name: string, target: { bookmark?: string; change?: string }): Promise<{ number: number; url: string }> {

    return this.request("POST", `/repos/${owner}/${name}/flow/runs`, target);

  }

  rerunFlowRun(owner: string, name: string, number: number): Promise<{ number: number; url: string }> {

    return this.request("POST", `/repos/${owner}/${name}/flow/runs/${number}/rerun`);

  }

  note?: string | null;

export type RequiredChecks = {

  names: string[];

};

};

export type AssetBuild = {

  artifact: string;

  job: string;

  receipt?: string | null;

  receipt_url?: string | null;

  run: number;

  run_url: string;

  signer?: string | null;

  built_by?: AssetBuild | null;

  url: string;

};

export type FlowJob = {

  depends_on: string[];

  error: string;

  exit_code?: number | null;

  finished_ms?: number | null;

  log_lines: number;

  name: string;

  runner: string;

  started_ms?: number | null;

  status: string;

};

export type FlowRun = {

  actor: string;

  bookmark: string;

  created_ms: number;

  error: string;

  finished_ms?: number | null;

  heads: string[];

  jobs?: FlowJob[];

  number: number;

  pipeline_hash: string;

  queue_position?: number | null;

  state: string;

  status: string;

  trigger: string;

};

export type FlowLogLine = {

  seq: number;

  stream: string;

  t: number;

  text: string;