OxygenHub 0.13.0: Drops in the editor with Share as a Drop (closes #7); Flow approvals, expedite, reports, timings and test results (closes #8); ready/draft, landable, trust reports, asset downloads and new repositories (closes #9) 991516a107fa

// Drops in the editor (spec §8.4): the addresses of drop files, the names

// shared files take, and the words the Drops view shows. No vscode imports,

// so it is tested with plain Node.

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

import { ago } from "./flowview";

export const DROP_SCHEME = "oxygenhub-drop";

/** Which drop file a document is: the hub, the drop's id, and the file's name ("" for the drop itself). */

export interface DropRef {

  base: string;

  id: string;

  name: string;

}

/** A drop file's URI parts: `/ID/NAME`, the hub in the query. */

export function dropUriParts(r: DropRef): { path: string; query: string } {

  return { path: `/${r.id}${r.name ? `/${r.name}` : ""}`, query: new URLSearchParams({ hub: r.base }).toString() };

}

/** Parse a drop file's URI parts back; undefined if they are not one. */

export function parseDropUri(path: string, query: string): DropRef | undefined {

  const base = new URLSearchParams(query).get("hub");

  const m = /^\/([0-9a-f]{24})(?:\/(.+))?$/.exec(path);

  if (!base || !m) {

    return undefined;

  }

  return { base, id: m[1], name: m[2] ?? "" };

}

/**

 * A drop's id from what someone pastes: the id, or its page on a hub

 * (`https://hub/OWNER/drops/ID` or `https://hub/drops/ID`).

 */

export function dropIdOf(text: string): string | undefined {

  const t = text.trim();

  if (/^[0-9a-f]{24}$/.test(t)) {

    return t;

  }

  const m = /\/drops\/([0-9a-f]{24})(?:[/?#].*)?$/.exec(t);

  return m ? m[1] : undefined;

}

/** The hub a pasted drop page is on, if it is a URL. */

export function dropBaseOf(text: string): string | undefined {

  const m = /^(https?:\/\/[^/]+)\//.exec(text.trim());

  return m ? m[1] : undefined;

}

/**

 * Names for files shared as one drop: each file's path below the folder

 * they all sit in, so two `index.ts` in different folders stay apart and a

 * single file keeps just its name. Paths use `/`.

 */

export function shareNames(paths: string[]): string[] {

  const parts = paths.map((p) => p.split(/[\\/]/).filter(Boolean));

  if (parts.length === 1) {

    return [parts[0][parts[0].length - 1]];

  }

  let common = 0;

  const shortest = Math.min(...parts.map((p) => p.length - 1));

  while (common < shortest && parts.every((p) => p[common] === parts[0][common])) {

    common++;

  }

  return parts.map((p) => p.slice(common).join("/"));

}

/** File extensions for a language with no file behind it (an untitled editor). */

const EXTENSIONS: Record<string, string> = {

  typescript: "ts",

  typescriptreact: "tsx",

  javascript: "js",

  javascriptreact: "jsx",

  rust: "rs",

  python: "py",

  go: "go",

  java: "java",

  c: "c",

  cpp: "cpp",

  csharp: "cs",

  shellscript: "sh",

  markdown: "md",

  json: "json",

  yaml: "yaml",

  toml: "toml",

  html: "html",

  css: "css",

  sql: "sql",

  ruby: "rb",

  php: "php",

  swift: "swift",

  kotlin: "kt",

  plaintext: "txt",

};

/** The name a selection is shared under: the file's own name, else `snippet.EXT` by its language. */

export function snippetName(fileName: string | undefined, languageId: string): string {

  if (fileName) {

    const base = fileName.split(/[\\/]/).pop();

    if (base) {

      return base;

    }

  }

  return `snippet.${EXTENSIONS[languageId] ?? "txt"}`;

}

/** A shared selection's title: the file and its lines. */

export function snippetTitle(name: string, startLine: number, endLine: number, whole: boolean): string {

  if (whole) {

    return name;

  }

  return startLine === endLine ? `${name}, line ${startLine}` : `${name}, lines ${startLine}–${endLine}`;

}

/** The text a selection shares: the selected lines' text with its shared indentation removed. */

export function dedent(text: string): string {

  const lines = text.replace(/\r\n/g, "\n").split("\n");

  const indents = lines.filter((l) => l.trim()).map((l) => /^[ \t]*/.exec(l)![0].length);

  const cut = indents.length ? Math.min(...indents) : 0;

  return lines.map((l) => l.slice(cut)).join("\n");

}

/** The HTML that embeds a drop in another page. */

export function embedSnippet(d: Pick<api.Drop, "embed_url" | "title" | "id">): string {

  const title = (d.title || d.id).replace(/"/g, """);

  return `<iframe src="${d.embed_url ?? ""}" title="${title}" width="100%" height="400" style="border:0" loading="lazy"></iframe>`;

}

/** A drop's line in the Drops view: its title, and what it holds. */

export function dropLabel(d: api.Drop): { label: string; description: string } {

  const files = d.files.length;

  const bits = [d.visibility === "secret" ? "secret" : "", `${files} file${files === 1 ? "" : "s"}`, d.stars ? `★ ${d.stars}` : "", d.forked_from ? "fork" : ""];

  return { label: d.title || d.files[0]?.name || d.id, description: bits.filter(Boolean).join(" · ") };

}

/** A comment's line, for the comments pick. */

export function commentLine(c: api.DropComment, now = Date.now()): { label: string; description: string; detail: string } {

  return { label: c.author, description: ago(c.created_ms, now), detail: c.body.replace(/\s+/g, " ").trim() };

}

// The Drops view (spec §8.4): your drops on each hub you are signed in to,

// and others' drops you open; each drop's files open as documents that save

// back to the hub as a new change. Share as a Drop makes one from a

// selection, an editor or files in the Explorer.

import * as vscode from "vscode";

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

import { HubAuth } from "./auth";

import { DROP_SCHEME, DropRef, commentLine, dedent, dropBaseOf, dropIdOf, dropLabel, dropUriParts, embedSnippet, parseDropUri, shareNames, snippetName, snippetTitle } from "./dropkit";

type Node =

  | { kind: "hub"; base: string }

  | { kind: "drop"; base: string; d: api.Drop; mine: boolean }

  | { kind: "file"; base: string; d: api.Drop; f: api.DropFile; mine: boolean };

export type DropNode = Extract<Node, { kind: "drop" }>;

export type DropFileNode = Extract<Node, { kind: "file" }>;

export function dropUri(r: DropRef): vscode.Uri {

  return vscode.Uri.from({ scheme: DROP_SCHEME, ...dropUriParts(r) });

}

export class DropsProvider implements vscode.TreeDataProvider<Node> {

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

  readonly onDidChangeTreeData = this.emitter.event;

  /** Others' drops opened this session, by hub. */

  private readonly opened = new Map<string, Map<string, api.Drop>>();

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

  constructor(private readonly auth: HubAuth) {}

  refresh(): void {

    this.emitter.fire();

  }

  /** Keep a drop in the view after opening, forking or sharing it. */

  remember(base: string, d: api.Drop): void {

    if (this.me.get(base) !== d.owner) {

      const m = this.opened.get(base) ?? new Map<string, api.Drop>();

      m.set(d.id, d);

      this.opened.set(base, m);

    }

    this.refresh();

  }

  forget(base: string, id: string): void {

    this.opened.get(base)?.delete(id);

    this.refresh();

  }

  private hubs(): string[] {

    return this.auth.all().map((s) => s.base);

  }

  getTreeItem(node: Node): vscode.TreeItem {

    switch (node.kind) {

      case "hub": {

        const item = new vscode.TreeItem(node.base.replace(/^https?:\/\//, ""), vscode.TreeItemCollapsibleState.Expanded);

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

        item.contextValue = "dropHub";

        return item;

      }

      case "drop": {

        const { label, description } = dropLabel(node.d);

        const item = new vscode.TreeItem(label, vscode.TreeItemCollapsibleState.Collapsed);

        item.id = `${node.base}/${node.d.id}`;

        item.description = node.mine ? description : `${node.d.owner} · ${description}`;

        item.iconPath = new vscode.ThemeIcon(node.d.visibility === "secret" ? "lock" : node.d.forked_from ? "repo-forked" : "note");

        const md = new vscode.MarkdownString(`**${label}** by ${node.d.owner}${node.d.description ? `\n\n${node.d.description}` : ""}\n\n${node.d.url}`);

        item.tooltip = md;

        // dropMine/dropOther, then whether the caller starred it.

        item.contextValue = `${node.mine ? "dropMine" : "dropOther"}${node.d.starred ? "Starred" : ""}`;

        return item;

      }

      case "file": {

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

        item.resourceUri = dropUri({ base: node.base, id: node.d.id, name: node.f.name });

        item.description = node.f.size >= 1024 ? `${(node.f.size / 1024).toFixed(1)} KiB` : `${node.f.size} B`;

        item.contextValue = node.mine ? "dropFileMine" : "dropFile";

        item.command = { title: "Open", command: "vscode.open", arguments: [item.resourceUri] };

        return item;

      }

    }

  }

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

    if (!node) {

      const hubs = this.hubs();

      return hubs.length === 1 ? this.dropsOf(hubs[0]) : hubs.map((base) => ({ kind: "hub" as const, base }));

    }

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

      return this.dropsOf(node.base);

    }

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

      return node.d.files.map((f) => ({ kind: "file" as const, base: node.base, d: node.d, f, mine: node.mine }));

    }

    return [];

  }

  private async dropsOf(base: string): Promise<Node[]> {

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

    try {

      if (!this.me.has(base)) {

        this.me.set(base, (await client.me()).username);

      }

      const mine = await client.drops();

      const others = [...(this.opened.get(base)?.values() ?? [])].filter((d) => !mine.some((m) => m.id === d.id));

      return [...mine.map((d) => ({ kind: "drop" as const, base, d, mine: true })), ...others.map((d) => ({ kind: "drop" as const, base, d, mine: false }))];

    } catch (e) {

      void vscode.window.showWarningMessage(`OxygenHub: ${(e as Error).message}`);

      return [];

    }

  }

}

/**

 * Drop files as a file system: reading fetches the drop, writing commits the

 * file to it (PATCH, one change per save), deleting removes it. A drop's own

 * folder lists its files.

 */

export class DropFileSystem implements vscode.FileSystemProvider {

  private readonly emitter = new vscode.EventEmitter<vscode.FileChangeEvent[]>();

  readonly onDidChangeFile = this.emitter.event;

  private readonly cache = new Map<string, { d: api.Drop; at: number }>();

  constructor(

    private readonly auth: HubAuth,

    private readonly changed: (base: string, d: api.Drop) => void,

  ) {}

  private ref(uri: vscode.Uri): DropRef {

    const r = parseDropUri(uri.path, uri.query);

    if (!r) {

      throw vscode.FileSystemError.FileNotFound(uri);

    }

    return r;

  }

  private async load(r: DropRef, fresh = false): Promise<api.Drop> {

    const key = `${r.base}/${r.id}`;

    const hit = this.cache.get(key);

    if (hit && !fresh && Date.now() - hit.at < 2000) {

      return hit.d;

    }

    const d = await this.auth.clientFor(r.base).drop(r.id);

    this.cache.set(key, { d, at: Date.now() });

    return d;

  }

  watch(): vscode.Disposable {

    return new vscode.Disposable(() => undefined);

  }

  async stat(uri: vscode.Uri): Promise<vscode.FileStat> {

    const r = this.ref(uri);

    const d = await this.load(r);

    if (!r.name) {

      return { type: vscode.FileType.Directory, ctime: d.created_ms, mtime: d.updated_ms, size: 0 };

    }

    const f = d.files.find((x) => x.name === r.name);

    if (f) {

      return { type: vscode.FileType.File, ctime: d.created_ms, mtime: d.updated_ms, size: f.size };

    }

    if (d.files.some((x) => x.name.startsWith(r.name + "/"))) {

      return { type: vscode.FileType.Directory, ctime: d.created_ms, mtime: d.updated_ms, size: 0 };

    }

    throw vscode.FileSystemError.FileNotFound(uri);

  }

  async readDirectory(uri: vscode.Uri): Promise<[string, vscode.FileType][]> {

    const r = this.ref(uri);

    const d = await this.load(r);

    const prefix = r.name ? r.name + "/" : "";

    const out = new Map<string, vscode.FileType>();

    for (const f of d.files.filter((x) => x.name.startsWith(prefix))) {

      const rest = f.name.slice(prefix.length);

      const [head, ...tail] = rest.split("/");

      out.set(head, tail.length ? vscode.FileType.Directory : vscode.FileType.File);

    }

    return [...out];

  }

  createDirectory(): void {

    throw vscode.FileSystemError.NoPermissions("A drop's folders come from its files' names.");

  }

  async readFile(uri: vscode.Uri): Promise<Uint8Array> {

    const r = this.ref(uri);

    const d = await this.load(r, true);

    const f = d.files.find((x) => x.name === r.name);

    if (!f) {

      throw vscode.FileSystemError.FileNotFound(uri);

    }

    // Text up to 512 KiB comes with the drop; anything else from its raw address.

    if (f.content !== undefined && f.content !== null) {

      return new TextEncoder().encode(f.content);

    }

    return this.auth.clientFor(r.base).download(f.raw_url);

  }

  async writeFile(uri: vscode.Uri, content: Uint8Array, options: { create: boolean; overwrite: boolean }): Promise<void> {

    const r = this.ref(uri);

    const d = await this.load(r);

    const exists = d.files.some((x) => x.name === r.name);

    if (!exists && !options.create) {

      throw vscode.FileSystemError.FileNotFound(uri);

    }

    if (exists && !options.overwrite) {

      throw vscode.FileSystemError.FileExists(uri);

    }

    const text = new TextDecoder("utf-8", { fatal: true }).decode(content);

    const next = await this.auth.clientFor(r.base).editDrop(r.id, { files: [{ name: r.name, content: text }], message: `${exists ? "Edit" : "Add"} ${r.name}` }).catch((e: Error) => {

      throw vscode.FileSystemError.Unavailable(e.message);

    });

    this.cache.set(`${r.base}/${r.id}`, { d: next, at: Date.now() });

    this.changed(r.base, next);

    this.emitter.fire([{ type: exists ? vscode.FileChangeType.Changed : vscode.FileChangeType.Created, uri }]);

  }

  async delete(uri: vscode.Uri): Promise<void> {

    const r = this.ref(uri);

    if (!r.name) {

      throw vscode.FileSystemError.NoPermissions("Delete the drop from the Drops view.");

    }

    const next = await this.auth.clientFor(r.base).editDrop(r.id, { files: [{ name: r.name, content: null }], message: `Remove ${r.name}` });

    this.cache.set(`${r.base}/${r.id}`, { d: next, at: Date.now() });

    this.changed(r.base, next);

    this.emitter.fire([{ type: vscode.FileChangeType.Deleted, uri }]);

  }

  rename(): void {

    throw vscode.FileSystemError.NoPermissions("Renaming a drop's file is not supported yet; add it under the new name and remove the old.");

  }

}

/** The hub to make a drop on: the only one signed in to, else ask. */

async function pickHub(auth: HubAuth): Promise<string | undefined> {

  const hubs = auth.all().map((s) => s.base);

  if (hubs.length === 0) {

    void vscode.window.showWarningMessage("OxygenHub: sign in to a hub first.", "Sign In").then((p) => p && vscode.commands.executeCommand("oxygenhub.signIn"));

    return undefined;

  }

  return hubs.length === 1 ? hubs[0] : vscode.window.showQuickPick(hubs, { placeHolder: "Make the drop on" });

}

/** Ask for a title (prefilled) and whether the drop is public or secret. */

async function askTitleAndVisibility(value: string): Promise<{ title: string; secret: boolean } | undefined> {

  const title = await vscode.window.showInputBox({ prompt: "Drop title", value, validateInput: (v) => (v.length > 200 ? "At most 200 characters" : undefined) });

  if (title === undefined) {

    return undefined;

  }

  const remembered = vscode.workspace.getConfiguration("oxygenhub").get<string>("dropVisibility", "secret");

  const options = [

    { label: "$(lock) Secret", description: "unlisted: anyone with its address can read it", secret: true },

    { label: "$(globe) Public", description: "listed on your Drops page", secret: false },

  ].sort((a) => ((a.secret ? "secret" : "public") === remembered ? -1 : 1));

  const pick = await vscode.window.showQuickPick(options, { placeHolder: "Who can find it" });

  return pick ? { title, secret: pick.secret } : undefined;

}

/** A new drop is made: say so, copy its address if asked, show it in the view. */

async function announce(drops: DropsProvider, base: string, d: api.Drop): Promise<void> {

  drops.remember(base, d);

  const copy = vscode.workspace.getConfiguration("oxygenhub").get<boolean>("copyDropLink", true);

  if (copy) {

    await vscode.env.clipboard.writeText(d.url);

  }

  const pick = await vscode.window.showInformationMessage(`OxygenHub: dropped "${d.title || d.id}"${copy ? "; its address is copied" : ""}.`, "Open on Hub", ...(copy ? [] : ["Copy Link"]));

  if (pick === "Open on Hub") {

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

  } else if (pick === "Copy Link") {

    await vscode.env.clipboard.writeText(d.url);

  }

}

/** Share as a Drop from the editor: the selection (its lines), or the whole document when nothing is selected. */

export async function shareSelection(auth: HubAuth, drops: DropsProvider, uri?: vscode.Uri): Promise<void> {

  const editor = vscode.window.activeTextEditor;

  const doc = editor && (!uri || editor.document.uri.toString() === uri.toString()) ? editor.document : uri ? await vscode.workspace.openTextDocument(uri) : undefined;

  if (!doc) {

    void vscode.window.showWarningMessage("OxygenHub: open a file, or select some code, to share as a drop.");

    return;

  }

  const sel = editor && editor.document === doc ? editor.selection : undefined;

  const whole = !sel || sel.isEmpty;

  const name = snippetName(doc.isUntitled ? undefined : doc.fileName, doc.languageId);

  let content = doc.getText();

  let start = 1;

  let end = doc.lineCount;

  if (!whole && sel) {

    const last = sel.end.character === 0 && sel.end.line > sel.start.line ? sel.end.line - 1 : sel.end.line;

    content = dedent(doc.getText(new vscode.Range(sel.start.line, 0, last, doc.lineAt(last).text.length))) + "\n";

    [start, end] = [sel.start.line + 1, last + 1];

  }

  const base = await pickHub(auth);

  if (!base) {

    return;

  }

  const asked = await askTitleAndVisibility(snippetTitle(name, start, end, whole));

  if (!asked) {

    return;

  }

  try {

    const d = await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: "OxygenHub: dropping…" }, () =>

      auth.clientFor(base).createDrop({ title: asked.title, secret: asked.secret, files: [{ name, content }] }),

    );

    await announce(drops, base, d);

  } catch (e) {

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

  }

}

/** Share files (the Explorer's selection, folders' files included) as one drop. */

export async function shareFiles(auth: HubAuth, drops: DropsProvider, uri?: vscode.Uri, uris?: vscode.Uri[]): Promise<void> {

  let picked = uris && uris.length ? uris : uri ? [uri] : vscode.window.activeTextEditor ? [vscode.window.activeTextEditor.document.uri] : [];

  if (!picked.length) {

    picked = (await vscode.window.showOpenDialog({ canSelectMany: true, openLabel: "Share as a Drop" })) ?? [];

  }

  const files: vscode.Uri[] = [];

  for (const u of picked) {

    const stat = await vscode.workspace.fs.stat(u);

    if (stat.type & vscode.FileType.Directory) {

      files.push(...(await vscode.workspace.findFiles(new vscode.RelativePattern(u, "**/*"), "**/{.oxy,.git,node_modules,target}/**", 51)));

    } else {

      files.push(u);

    }

  }

  if (!files.length) {

    return;

  }

  if (files.length > 50) {

    void vscode.window.showWarningMessage("OxygenHub: a drop takes at most 50 files; push larger sets with oxy.");

    return;

  }

  const names = shareNames(files.map((f) => f.path));

  const contents: api.NewDropFile[] = [];

  for (const [i, f] of files.entries()) {

    const bytes = await vscode.workspace.fs.readFile(f);

    if (bytes.length > 1 << 20) {

      void vscode.window.showWarningMessage(`OxygenHub: ${names[i]} is larger than 1 MiB; a drop's files are at most that.`);

      return;

    }

    try {

      contents.push({ name: names[i], content: new TextDecoder("utf-8", { fatal: true }).decode(bytes) });

    } catch {

      void vscode.window.showWarningMessage(`OxygenHub: ${names[i]} is not text; a drop shares text files.`);

      return;

    }

  }

  const base = await pickHub(auth);

  if (!base) {

    return;

  }

  const asked = await askTitleAndVisibility(names.length === 1 ? names[0] : `${names[0]} and ${names.length - 1} more`);

  if (!asked) {

    return;

  }

  try {

    const d = await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: "OxygenHub: dropping…" }, () =>

      auth.clientFor(base).createDrop({ title: asked.title, secret: asked.secret, files: contents }),

    );

    await announce(drops, base, d);

  } catch (e) {

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

  }

}

/** The drop commands that act on the view's items. */

export function registerDropCommands(auth: HubAuth, drops: DropsProvider): vscode.Disposable[] {

  const client = (base: string) => auth.clientFor(base);

  const guard =

    <A extends unknown[]>(f: (...a: A) => Promise<unknown>) =>

    async (...a: A) => {

      try {

        await f(...a);

      } catch (e) {

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

      }

    };

  const open = async (base: string, d: api.Drop) => {

    drops.remember(base, d);

    if (d.files.length) {

      await vscode.window.showTextDocument(dropUri({ base, id: d.id, name: d.files[0].name }), { preview: false });

    }

  };

  return [

    vscode.commands.registerCommand("oxygenhub.dropsRefresh", () => drops.refresh()),

    vscode.commands.registerCommand(

      "oxygenhub.newDrop",

      guard(async () => {

        const base = await pickHub(auth);

        if (!base) {

          return;

        }

        const name = await vscode.window.showInputBox({ prompt: "First file's name", value: "notes.md", validateInput: (v) => (v.trim() ? undefined : "Every file needs a name") });

        if (!name) {

          return;

        }

        const asked = await askTitleAndVisibility("");

        if (!asked) {

          return;

        }

        const d = await client(base).createDrop({ title: asked.title, secret: asked.secret, files: [{ name: name.trim(), content: "" }] });

        drops.refresh();

        await open(base, d);

      }),

    ),

    vscode.commands.registerCommand(

      "oxygenhub.openDrop",

      guard(async () => {

        const text = await vscode.window.showInputBox({ prompt: "A drop's address or id", placeHolder: "https://hub/OWNER/drops/ID", validateInput: (v) => (dropIdOf(v) ? undefined : "A drop's page or its 24-digit id") });

        if (!text) {

          return;

        }

        const id = dropIdOf(text)!;

        const pasted = dropBaseOf(text);

        const base = pasted && auth.bases().includes(pasted) ? pasted : pasted ?? (await pickHub(auth));

        if (!base) {

          return;

        }

        await open(base, await client(base).drop(id));

      }),

    ),

    vscode.commands.registerCommand("oxygenhub.openDropOnHub", (n: DropNode) => vscode.env.openExternal(vscode.Uri.parse(n.d.url))),

    vscode.commands.registerCommand("oxygenhub.copyDropLink", async (n: DropNode) => {

      await vscode.env.clipboard.writeText(n.d.url);

      vscode.window.setStatusBarMessage("$(link) Drop address copied", 3000);

    }),

    vscode.commands.registerCommand("oxygenhub.copyDropClone", async (n: DropNode) => {

      await vscode.env.clipboard.writeText(`oxy clone ${n.d.clone_url}`);

      vscode.window.setStatusBarMessage("$(terminal) oxy clone command copied", 3000);

    }),

    vscode.commands.registerCommand("oxygenhub.copyDropEmbed", async (n: DropNode) => {

      await vscode.env.clipboard.writeText(embedSnippet(n.d));

      vscode.window.setStatusBarMessage("$(code) Embed HTML copied", 3000);

    }),

    vscode.commands.registerCommand(

      "oxygenhub.cloneDrop",

      guard(async (n: DropNode) => {

        const parent = await vscode.window.showOpenDialog({ canSelectFolders: true, canSelectFiles: false, openLabel: "Clone Here" });

        if (!parent?.[0]) {

          return;

        }

        const t = vscode.window.createTerminal({ name: "OxygenHub", cwd: parent[0].fsPath });

        t.show();

        t.sendText(`oxy clone ${n.d.clone_url} drop-${n.d.id.slice(0, 8)}`);

      }),

    ),

    vscode.commands.registerCommand(

      "oxygenhub.editDrop",

      guard(async (n: DropNode) => {

        const title = await vscode.window.showInputBox({ prompt: "Title", value: n.d.title });

        if (title === undefined) {

          return;

        }

        const description = await vscode.window.showInputBox({ prompt: "Description", value: n.d.description });

        if (description === undefined) {

          return;

        }

        await client(n.base).editDrop(n.d.id, { title, description });

        drops.refresh();

      }),

    ),

    vscode.commands.registerCommand(

      "oxygenhub.toggleDropVisibility",

      guard(async (n: DropNode) => {

        const secret = n.d.visibility !== "secret";

        await client(n.base).editDrop(n.d.id, { secret });

        drops.refresh();

        vscode.window.setStatusBarMessage(secret ? "$(lock) The drop is secret now" : "$(globe) The drop is public now", 3000);

      }),

    ),

    vscode.commands.registerCommand(

      "oxygenhub.addDropFile",

      guard(async (n: DropNode) => {

        const name = await vscode.window.showInputBox({ prompt: `New file in "${n.d.title || n.d.id}"`, validateInput: (v) => (!v.trim() ? "Every file needs a name" : n.d.files.some((f) => f.name === v.trim()) ? "The drop has a file by that name" : undefined) });

        if (!name) {

          return;

        }

        await client(n.base).editDrop(n.d.id, { files: [{ name: name.trim(), content: "" }], message: `Add ${name.trim()}` });

        drops.refresh();

        await vscode.window.showTextDocument(dropUri({ base: n.base, id: n.d.id, name: name.trim() }), { preview: false });

      }),

    ),

    vscode.commands.registerCommand(

      "oxygenhub.deleteDropFile",

      guard(async (n: DropFileNode) => {

        if (n.d.files.length === 1) {

          void vscode.window.showWarningMessage("OxygenHub: a drop keeps at least one file; delete the drop instead.");

          return;

        }

        const ok = await vscode.window.showWarningMessage(`Remove ${n.f.name} from the drop?`, { modal: true, detail: "Its history keeps it." }, "Remove");

        if (ok) {

          await client(n.base).editDrop(n.d.id, { files: [{ name: n.f.name, content: null }], message: `Remove ${n.f.name}` });

          drops.refresh();

        }

      }),

    ),

    vscode.commands.registerCommand(

      "oxygenhub.deleteDrop",

      guard(async (n: DropNode) => {

        const ok = await vscode.window.showWarningMessage(`Delete the drop "${n.d.title || n.d.id}"?`, { modal: true, detail: "It and its history are gone for good, and its address stops working." }, "Delete");

        if (ok) {

          await client(n.base).deleteDrop(n.d.id);

          drops.forget(n.base, n.d.id);

        }

      }),

    ),

    vscode.commands.registerCommand(

      "oxygenhub.forkDrop",

      guard(async (n: DropNode) => {

        const d = await client(n.base).forkDrop(n.d.id);

        drops.refresh();

        await open(n.base, d);

        vscode.window.setStatusBarMessage(`$(repo-forked) Forked "${n.d.title || n.d.id}"`, 3000);

      }),

    ),

    vscode.commands.registerCommand(

      "oxygenhub.starDrop",

      guard(async (n: DropNode) => {

        const s = await client(n.base).starDrop(n.d.id, true);

        drops.remember(n.base, { ...n.d, ...s });

      }),

    ),

    vscode.commands.registerCommand(

      "oxygenhub.unstarDrop",

      guard(async (n: DropNode) => {

        const s = await client(n.base).starDrop(n.d.id, false);

        drops.remember(n.base, { ...n.d, ...s });

      }),

    ),

    vscode.commands.registerCommand(

      "oxygenhub.dropComments",

      guard(async (n: DropNode) => {

        const c = client(n.base);

        const me = (await c.me()).username;

        const comments = await c.dropComments(n.d.id);

        type Item = vscode.QuickPickItem & { add?: boolean; comment?: api.DropComment };

        const items: Item[] = [{ label: "$(comment) Add a comment…", add: true }, ...comments.map((x) => ({ ...commentLine(x), comment: x }))];

        const pick = await vscode.window.showQuickPick(items, { placeHolder: `${comments.length} comment${comments.length === 1 ? "" : "s"} on "${n.d.title || n.d.id}"`, matchOnDetail: true });

        if (pick?.add) {

          const body = await vscode.window.showInputBox({ prompt: "Comment (Markdown)" });

          if (body?.trim()) {

            await c.commentDrop(n.d.id, body);

            vscode.window.setStatusBarMessage("$(comment) Commented", 3000);

          }

        } else if (pick?.comment) {

          const mayDelete = pick.comment.author === me || n.d.owner === me;

          const act = await vscode.window.showInformationMessage(`${pick.comment.author}: ${pick.comment.body}`, ...(mayDelete ? ["Delete Comment"] : []));

          if (act === "Delete Comment") {

            await c.deleteDropComment(n.d.id, pick.comment.id);

          }

        }

      }),

    ),

  ];

}

// New Repository… (spec §8.5): a repository on a hub under you or one of

// your organisations, optionally with an assistant's starting files (#347),

// then cloned into a folder you choose.

import * as vscode from "vscode";

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

import { HubAuth } from "./auth";

const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;

export async function newRepository(auth: HubAuth): Promise<void> {

  const hubs = auth.all().map((s) => s.base);

  const base = hubs.length === 1 ? hubs[0] : await vscode.window.showQuickPick(hubs, { placeHolder: "Create the repository on" });

  if (!base) {

    if (!hubs.length) {

      void vscode.window.showWarningMessage("OxygenHub: sign in to a hub first.");

    }

    return;

  }

  const client = auth.clientFor(base);

  const [me, orgs] = await Promise.all([client.me(), client.orgs().catch(() => [] as api.Organisation[])]);

  const owner = orgs.length

    ? (await vscode.window.showQuickPick([{ label: me.username, description: "you" }, ...orgs.map((o) => ({ label: o.name, description: o.display_name }))], { placeHolder: "Owner" }))?.label

    : me.username;

  if (!owner) {

    return;

  }

  const name = await vscode.window.showInputBox({ prompt: `Repository name under ${owner}`, validateInput: (v) => (NAME.test(v) ? undefined : "Letters, digits, '.', '_' and '-', starting with a letter or digit") });

  if (!name) {

    return;

  }

  const description = (await vscode.window.showInputBox({ prompt: "What is it for? (optional; an assistant can draft its starting files from this)" })) ?? "";

  const vis = await vscode.window.showQuickPick(

    [

      { label: "$(lock) Private", value: "private" as const },

      { label: "$(organization) Internal", description: "everyone signed in to the hub", value: "internal" as const },

      { label: "$(globe) Public", value: "public" as const },

    ],

    { placeHolder: "Visibility" },

  );

  if (!vis) {

    return;

  }

  try {

    const repo = await client.createRepository({ owner, name, description, visibility: vis.value });

    if (description.trim()) {

      await offerStarter(client, repo, description.trim());

    }

    const pick = await vscode.window.showInformationMessage(`OxygenHub: created ${owner}/${name}.`, "Clone", "Open on Hub");

    if (pick === "Open on Hub") {

      void vscode.env.openExternal(vscode.Uri.parse(`${base}/${owner}/${name}`));

    } else if (pick === "Clone") {

      const parent = await vscode.window.showOpenDialog({ canSelectFolders: true, canSelectFiles: false, openLabel: "Clone Here" });

      if (parent?.[0]) {

        const t = vscode.window.createTerminal({ name: "OxygenHub", cwd: parent[0].fsPath });

        t.show();

        t.sendText(`oxy clone ${repo.clone_url} ${name}`);

      }

    }

  } catch (e) {

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

  }

}

/** When the owner has an assistant, offer its starting files, and wait for them. */

async function offerStarter(client: ReturnType<HubAuth["clientFor"]>, repo: api.Repository, description: string): Promise<void> {

  const { assistants } = await client.starterAssistants(repo.owner).catch(() => ({ assistants: [] as api.StarterAssistant[] }));

  if (!assistants.length) {

    return;

  }

  const pick = await vscode.window.showQuickPick(

    [{ label: "$(close) No, start empty" }, ...assistants.map((a) => ({ label: `$(sparkle) Ask ${a.name}`, description: `${a.model}, from ${a.from}`, assistant: a.name }))],

    { placeHolder: "Ask an assistant for its starting files (a README, build files, a first test)?" },

  );

  if (!pick || !("assistant" in pick)) {

    return;

  }

  await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: `OxygenHub: ${pick.assistant} is drafting the starting files…`, cancellable: true }, async (_p, token) => {

    let s = await client.startStarter(repo.owner, repo.name, { description, assistant: pick.assistant });

    // A model may take a few minutes; the hub commits the files when it is done.

    for (let i = 0; i < 120 && s.status === "running" && !token.isCancellationRequested; i++) {

      await new Promise((r) => setTimeout(r, 3000));

      s = await client.starterStatus(repo.owner, repo.name);

    }

    if (s.status === "done") {

      void vscode.window.showInformationMessage(`OxygenHub: ${s.assistant} committed ${s.files?.length ?? 0} starting file(s).`);

    } else if (s.status === "failed") {

      void vscode.window.showWarningMessage(`OxygenHub: the starter failed: ${s.error}`);

    } else if (s.status === "running") {

      void vscode.window.showInformationMessage("OxygenHub: the starter is still being drafted; the hub commits it when done.");

    }

  });

}

// Flow's test reports in VS Code's Testing view (spec §9.2): the newest

// report on each repository's current bookmark, its suites and cases with

// their results, messages and output. Nothing runs here: running a test

// loads the hub's latest results.

import * as vscode from "vscode";

import { HubAuth } from "./auth";

import { caseId, caseOutcome, casesBySuite, duration } from "./flowview";

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

export class HubTests implements vscode.Disposable {

  private readonly controller: vscode.TestController;

  constructor(

    private readonly auth: HubAuth,

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

  ) {

    this.controller = vscode.tests.createTestController("oxygenhub", "OxygenFlow test reports");

    this.controller.refreshHandler = () => this.load();

    this.controller.createRunProfile("Load the hub's latest results", vscode.TestRunProfileKind.Run, () => this.load(), true);

  }

  dispose(): void {

    this.controller.dispose();

  }

  /** Fetch each repository's newest test report and show its results. */

  async load(): Promise<void> {

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

    const roots: vscode.TestItem[] = [];

    const results: [vscode.TestItem, string, string, string, number][] = [];

    for (const repo of repos) {

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

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

      const [newest] = await client.testReports(repo.owner, repo.name, bookmark, 1).catch(() => []);

      if (!newest) {

        continue;

      }

      const detail = await client.testReport(repo.owner, repo.name, newest.id).catch(() => undefined);

      if (!detail) {

        continue;

      }

      const key = `${repo.base}/${repo.owner}/${repo.name}`;

      const r = detail.report;

      const root = this.controller.createTestItem(key, `${repo.owner}/${repo.name}`);

      root.description = `${r.passed}/${r.tests} passed${r.failed ? ` · ${r.failed} failed` : ""} · run #${r.run} ${r.job} on ${r.bookmark}`;

      for (const [suite, cases] of casesBySuite(detail.cases)) {

        const s = this.controller.createTestItem(`${key}::${suite}`, suite);

        for (const c of cases) {

          const item = this.controller.createTestItem(caseId(key, c), c.name);

          item.description = c.classname && c.classname !== suite ? c.classname : undefined;

          s.children.add(item);

          results.push([item, c.status, c.message, c.output, c.time_ms]);

        }

        root.children.add(s);

      }

      roots.push(root);

    }

    this.controller.items.replace(roots);

    const run = this.controller.createTestRun(new vscode.TestRunRequest(), "OxygenFlow", false);

    for (const [item, status, message, output, ms] of results) {

      const outcome = caseOutcome(status);

      if (outcome === "passed") {

        run.passed(item, ms);

      } else if (outcome === "skipped") {

        run.skipped(item);

      } else {

        const m = new vscode.TestMessage(message || `${status} after ${duration(ms)}`);

        if (output) {

          m.actualOutput = output;

        }

        (outcome === "failed" ? run.failed : run.errored).call(run, item, m, ms);

      }

    }

    run.end();

  }

}

import { test } from "node:test";

import assert from "node:assert/strict";

import { dedent, dropBaseOf, dropIdOf, dropLabel, dropUriParts, embedSnippet, parseDropUri, shareNames, snippetName, snippetTitle, commentLine } from "../out/dropkit.mjs";

const ID = "0123456789abcdef01234567";

test("drop file addresses round trip, folders and all", () => {

  const r = { base: "https://hub.example:7343", id: ID, name: "src/lib/a.ts" };

  const { path, query } = dropUriParts(r);

  assert.equal(path, `/${ID}/src/lib/a.ts`);

  assert.deepEqual(parseDropUri(path, query), r);

  assert.deepEqual(parseDropUri(`/${ID}`, query), { ...r, name: "" }, "the drop itself");

  assert.equal(parseDropUri("/not-an-id/a.ts", query), undefined);

  assert.equal(parseDropUri(path, ""), undefined, "no hub, no drop");

});

test("a pasted drop is its id or its page", () => {

  assert.equal(dropIdOf(ID), ID);

  assert.equal(dropIdOf(` https://oxygenhub.io/andy/drops/${ID} `), ID);

  assert.equal(dropIdOf(`https://oxygenhub.io/drops/${ID}?tab=history`), ID);

  assert.equal(dropIdOf("https://oxygenhub.io/andy/oxygen"), undefined);

  assert.equal(dropBaseOf(`https://oxygenhub.io/andy/drops/${ID}`), "https://oxygenhub.io");

  assert.equal(dropBaseOf(ID), undefined);

});

test("shared files keep their paths below the folder they share", () => {

  assert.deepEqual(shareNames(["/w/p/src/a/index.ts"]), ["index.ts"], "one file: its name");

  assert.deepEqual(shareNames(["/w/p/src/a/index.ts", "/w/p/src/b/index.ts"]), ["a/index.ts", "b/index.ts"], "two index.ts stay apart");

  assert.deepEqual(shareNames(["/w/p/README.md", "/w/p/src/main.rs"]), ["README.md", "src/main.rs"]);

  assert.deepEqual(shareNames(["C:\\w\\p\\a.txt", "C:\\w\\p\\b.txt"]), ["a.txt", "b.txt"], "Windows paths");

});

test("a selection is named and titled by its file and lines", () => {

  assert.equal(snippetName("/w/p/src/main.rs", "rust"), "main.rs");

  assert.equal(snippetName(undefined, "python"), "snippet.py", "an untitled editor by its language");

  assert.equal(snippetName(undefined, "cobol"), "snippet.txt");

  assert.equal(snippetTitle("main.rs", 3, 9, false), "main.rs, lines 3–9");

  assert.equal(snippetTitle("main.rs", 3, 3, false), "main.rs, line 3");

  assert.equal(snippetTitle("main.rs", 1, 40, true), "main.rs");

  assert.equal(dedent("    fn a() {\n        b();\n\n    }"), "fn a() {\n    b();\n\n}", "shared indentation goes, blank lines stay");

});

test("a drop's line, embed and comments", () => {

  const d = { id: ID, owner: "andy", title: "", description: "", visibility: "secret", url: "", clone_url: "", created_ms: 0, updated_ms: 0, files: [{ name: "a.md", size: 3, raw_url: "" }], stars: 2, starred: false, forked_from: "/x/drops/y", embed_url: "https://hub/andy/drops/x/embed" };

  assert.deepEqual(dropLabel(d), { label: "a.md", description: "secret · 1 file · ★ 2 · fork" });

  assert.deepEqual(dropLabel({ ...d, title: "Notes", visibility: "public", stars: 0, forked_from: null, files: [...d.files, d.files[0]] }), { label: "Notes", description: "2 files" });

  assert.equal(embedSnippet({ ...d, title: 'say "hi"' }), '<iframe src="https://hub/andy/drops/x/embed" title="say &quot;hi&quot;" width="100%" height="400" style="border:0" loading="lazy"></iframe>');

  const line = commentLine({ id: 1, author: "sky", body: "nice\n\nthanks", created_ms: 0 }, 10_000);

  assert.deepEqual(line, { label: "sky", description: "just now", detail: "nice thanks" });

});

## 0.13.0 (2026-10-29)

- **Drops in the editor (#7).** A **Drops** view lists your drops and the ones you open; a drop's files open as documents, and **saving commits** them to the drop. **Share as a Drop…** shares a selection or a file from the editor, **Share Files as a Drop…** files or a folder from the Explorer, secret or public, with the address copied for you. From a drop's menu: add and remove files, edit its title, make it public or secret, copy its link, `oxy clone` command or embed HTML, clone it, read and add comments, star it, and fork someone else's. Needs OxygenHub 0.9.17.

- **Flow: approvals, expedite, reports, timings and test results (#8).** Approve or reject a job waiting on its approval rules, expedite or cancel a run, see where a job's time went in its tooltip, and open the reports it published. Flow's test reports appear in VS Code's **Testing** view, suite by suite, with failure messages and output.

- **Proposals, releases and repositories (#9).** **Mark Ready for Review** and **Convert to Draft**; **Ready to Land…** lists what you can land now across your hubs. A release's **Show Trust Report** shows its signatures, builds and audit; **Save Asset…** downloads an asset, private ones included. **New Repository…** creates one under you or an organisation, optionally with an assistant's starting files.

2. Open a repository whose remote is on that hub. The **OxygenHub** activity bar icon shows Proposals, Issues, Releases, Flow, Diffusion and Drops for it, and Flow's test reports appear in the Testing view.

### Share code as a drop

A drop is a small set of files with its own history, on the hub, with an address you can pass on.

1. Select some lines in an editor and choose **Share as a Drop…** from its right-click menu (or an editor tab's menu, for the whole file). In the Explorer, **Share Files as a Drop…** takes one or more files or a folder.

2. Give it a title and choose **Secret** (unlisted: anyone with its address can read it) or **Public** (listed on your Drops page). Its address is copied for you.

3. In **Drops**, click a file to open it; saving it commits a new change to the drop. A drop's menu adds or removes files, changes its title, makes it public or secret, copies its link, its `oxy clone` command or the HTML to embed it, clones it, and shows or adds comments.

4. **Open a Drop…** takes someone's drop by its address, to read it, **Star** it, comment on it or **Fork** it into a drop of your own.

### Check a release's trust

On a release in **Releases**, **Show Trust Report** shows who signed the tag and the changes, which OxygenFlow build made each asset, and the audit's verdicts. **Save Asset…** downloads an asset, with your token when the repository is private.

### Approve, expedite and read reports in Flow

A job waiting on its approval rules shows a shield in **Flow**: **Approve Job** or **Reject Job…** decides it. A queued or running run's menu has **Expedite Run…** (say why; it goes ahead of the queue) and **Cancel Run**. A job's tooltip says how long it waited and where its time went; **Show Reports…** lists what it published.

### Start a repository

**New Repository…** (the Proposals view's `…` menu) creates one under you or an organisation. When you say what it is for and the owner has an assistant, it can draft the starting files. Then it is cloned where you choose.

| `oxygenhub.dropVisibility` | `"secret"` | Which **Share as a Drop** offers first: `secret` or `public`. |

| `oxygenhub.copyDropLink` | `true` | Copy a new drop's address to the clipboard. |

The **OxygenHub: Proposals** view lists, per repository that has a hub remote, proposals in three groups: needing me (open, not mine, where I have not approved or where my approval is pending a seal), mine, and other open ones. Each row shows number, title, author, target, state chips (draft, conflicted, landable) and the check summary. Actions: open detail, open on hub, check out, review (comment / request changes / approve), seal approval, land, close, and **Mark Ready for Review** on a draft or **Convert to Draft** on an open one (`PATCH …/proposals/N {"draft"}`, oxygenhub#313).

**Ready to Land…** (the Proposals view's title bar) lists, across every signed-in hub, the open proposals the user could land now (`GET /user/proposals?landable=true`, oxygenhub#311): approved, checks passed, no conflicts, in repositories they write to. One in the workspace is landed with `oxy proposal land` or opened; any other opens on the hub.

The **Releases** view lists each repository's releases, newest first (`GET /repos/{o}/{n}/releases`): title, tag, `latest` or `pre-release`, date; the tooltip shows the start of the notes. Expanding a release lists its uploaded assets (size, downloads) and the hub's source archives; picking one downloads it through the browser, picking the release opens it on the hub. **Save Asset…** (inline on an asset) downloads it into a file the user picks, with the session's token, so a private repository's assets come too; the token is sent only to the hub itself.

**Show Trust Report** (inline on a release) opens the hub's trust report (`GET …/releases/trust/{tag}`, oxygenhub#79) as a Markdown preview: the tag's signature and signer, the changes since the previous release, each author's signed, sealed, unsigned, revoked and invalid changes, which attested OxygenFlow build made each asset (and whether it built the tagged state), and the audit's verdicts.

### 8.4 Drops

The **Drops** view lists the user's drops on each signed-in hub (`GET /drops`; grouped by hub when there is more than one), then others' drops opened this session. A row shows the title (else the first file's name), and whether it is secret, its files, its stars and whether it is a fork; expanding it lists the files. A file opens as a document of the `oxygenhub-drop` scheme (`/ID/NAME?hub=BASE`), served by a `FileSystemProvider`: reading takes the content from `GET /drops/{id}` (text up to 512 KiB) or the file's raw address; **saving commits** the file to the drop (`PATCH /drops/{id}` with that one file, message `Edit NAME`), so each save is a change in the drop's history; deleting removes the file the same way. Renaming is refused (add it under the new name and remove the old).

**Share as a Drop…** (an editor's context menu, an editor tab's menu) shares the selection, or the whole document when nothing is selected: the selected lines, their shared indentation removed, under the file's name (an untitled editor's by its language, `snippet.py`), titled with the file and lines (`main.rs, lines 3–9`). **Share Files as a Drop…** (the Explorer's menu) shares the selected files, a folder's files (skipping `.oxy`, `.git`, `node_modules` and `target`), named by their paths below the folder they share, so two `index.ts` stay apart. Both ask for the title and **Secret** (unlisted, readable with its address) or **Public**, the one `oxygenhub.dropVisibility` names offered first, then make it (`POST /drops`) and copy its address (`oxygenhub.copyDropLink`). The hub's limits apply (50 files, 1 MiB each, text, push protection), and its refusals are shown as they are.

A drop's menu: **Add File…**, **Edit Title and Description…**, **Make Public / Secret** and **Delete Drop…** (with a modal; it and its history are gone) for the user's own; **Copy Drop Link**, **Copy oxy clone Command**, **Copy Embed HTML** (an `<iframe>` of its embed address), **Clone Drop…** (`oxy clone` in a terminal, into a folder the user picks), **Comments…** (a pick of its comments with *Add a comment…*; the comment's author or the drop's owner may delete one) and **Star** / **Unstar** for any; **Fork Drop** for others' (`POST /drops/{id}/fork`, oxygenhub#349), which opens the copy. **Open a Drop…** takes a drop's page or id; a page on a hub the user is not signed in to is read anonymously, as a secret drop's address allows.

### 8.5 New repository

**New Repository…** creates a repository (`POST /repos`) on a signed-in hub under the user or one of their organisations (`GET /user/orgs`), with a name, an optional description and a visibility. When there is a description and the owner has assistants (`GET /user/starter?owner=`, oxygenhub#347), it offers to ask one for the starting files (`POST …/starter`) and follows `GET …/starter` until they are committed, failed, or about six minutes have passed (the hub finishes either way). Then it offers to clone it (`oxy clone` in a terminal) or open it on the hub.

### 9.2 Test results

A `TestController` puts the newest OxygenFlow test report of each repository's current bookmark (`GET …/tests?bookmark=&limit=1`, then `GET …/tests/{id}`) in VS Code's Testing view: the repository, then its suites, then its cases, each with its result, time, failure message and output. A case's id is the repository, suite, class and name, so the Testing view's history lines up across reports. Nothing runs locally: running a test, or refreshing, loads the hub's latest results again; refresh also follows the views' refresh.

### 9.3 Flow

In the **Flow** view, a job waiting on its approval rules (`approval` `waiting` while queued, oxygenflow#57) shows a shield and "waiting for approval", with **Approve Job** and **Reject Job…** (a modal: the run fails) inline (`POST …/jobs/{job}/approve|reject`). A queued or running run has **Expedite Run…** (asks why; `POST …/expedite`, oxygenhub#244) and **Cancel Run**. A job's tooltip gives its timings (#348): how long it waited for a runner, each phase its runner reported, and its peak disk and memory. **Show Reports…** on a job lists the reports it published (title, summary, metrics) and opens the picked one on the hub.

`oxygenhub.hubs`: known hub base URLs (also learnt from sign in). `oxygenhub.proposalBookmarkPrefix`: `proposal/`. `oxygenhub.autoRefresh`: seconds between view refreshes (60). `oxygenhub.dropVisibility`: what Share as a Drop offers first, `secret` (default) or `public`. `oxygenhub.copyDropLink`: copy a new drop's address (true).

  "version": "0.13.0",

        },

        "oxygenhub.dropVisibility": {

          "type": "string",

          "enum": [

            "secret",

            "public"

          ],

          "default": "secret",

          "description": "Which Share as a Drop offers first: secret (unlisted, readable with its address) or public (listed on your Drops page)."

        },

        "oxygenhub.copyDropLink": {

          "type": "boolean",

          "default": true,

          "description": "Copy a new drop's address to the clipboard when it is made."

        },

        {

          "id": "oxygenhub.drops",

          "name": "Drops"

      },

      {

        "view": "oxygenhub.drops",

        "contents": "Drops are small shareable sets of files: snippets, notes, configs, each with its own history.\n[New Drop](command:oxygenhub.newDrop)\n[Open a Drop](command:oxygenhub.openDrop)\nSelect code in an editor and choose Share as a Drop from its menu."

        "category": "OxygenHub",

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

      },

      {

        "command": "oxygenhub.dropsRefresh",

        "title": "Refresh Drops",

        "category": "OxygenHub",

        "icon": "$(refresh)"

      },

      {

        "command": "oxygenhub.newDrop",

        "title": "New Drop\u2026",

        "category": "OxygenHub",

        "icon": "$(add)"

      },

      {

        "command": "oxygenhub.openDrop",

        "title": "Open a Drop\u2026",

      },

      {

        "command": "oxygenhub.shareSelectionAsDrop",

        "title": "Share as a Drop\u2026",

        "category": "OxygenHub",

        "icon": "$(cloud-upload)"

      },

      {

        "command": "oxygenhub.shareFilesAsDrop",

        "title": "Share Files as a Drop\u2026",

        "category": "OxygenHub",

        "icon": "$(cloud-upload)"

      },

      {

        "command": "oxygenhub.openDropOnHub",

        "title": "Open Drop on Hub",

        "category": "OxygenHub",

        "icon": "$(globe)"

      },

      {

        "command": "oxygenhub.copyDropLink",

        "title": "Copy Drop Link",

        "category": "OxygenHub",

        "icon": "$(link)"

      },

      {

        "command": "oxygenhub.copyDropClone",

        "title": "Copy oxy clone Command",

        "category": "OxygenHub"

      },

      {

        "command": "oxygenhub.copyDropEmbed",

        "title": "Copy Embed HTML",

        "category": "OxygenHub"

      },

      {

        "command": "oxygenhub.cloneDrop",

        "title": "Clone Drop\u2026",

        "category": "OxygenHub"

      },

      {

        "command": "oxygenhub.editDrop",

        "title": "Edit Title and Description\u2026",

        "category": "OxygenHub",

        "icon": "$(edit)"

      },

      {

        "command": "oxygenhub.toggleDropVisibility",

        "title": "Make Public / Secret",

        "category": "OxygenHub"

      },

      {

        "command": "oxygenhub.addDropFile",

        "title": "Add File\u2026",

        "category": "OxygenHub",

        "icon": "$(new-file)"

      },

      {

        "command": "oxygenhub.deleteDropFile",

        "title": "Remove File from Drop",

        "category": "OxygenHub"

      },

      {

        "command": "oxygenhub.deleteDrop",

        "title": "Delete Drop\u2026",

        "category": "OxygenHub",

        "icon": "$(trash)"

      },

      {

        "command": "oxygenhub.forkDrop",

        "title": "Fork Drop",

        "category": "OxygenHub",

        "icon": "$(repo-forked)"

      },

      {

        "command": "oxygenhub.starDrop",

        "title": "Star Drop",

        "category": "OxygenHub",

        "icon": "$(star-empty)"

      },

      {

        "command": "oxygenhub.unstarDrop",

        "title": "Unstar Drop",

        "category": "OxygenHub",

        "icon": "$(star-full)"

      },

      {

        "command": "oxygenhub.dropComments",

        "title": "Comments\u2026",

        "category": "OxygenHub",

        "icon": "$(comment-discussion)"

      },

      {

        "command": "oxygenhub.approveJob",

        "title": "Approve Job",

        "category": "OxygenFlow",

        "icon": "$(pass)"

      },

      {

        "command": "oxygenhub.rejectJob",

        "title": "Reject Job\u2026",

        "category": "OxygenFlow",

        "icon": "$(close)"

      },

      {

        "command": "oxygenhub.expediteRun",

        "title": "Expedite Run\u2026",

        "category": "OxygenFlow",

        "icon": "$(rocket)"

      },

      {

        "command": "oxygenhub.cancelRun",

        "title": "Cancel Run",

        "category": "OxygenFlow",

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

      },

      {

        "command": "oxygenhub.jobReports",

        "title": "Show Reports\u2026",

        "category": "OxygenFlow",

        "icon": "$(graph)"

      },

      {

        "command": "oxygenhub.releaseTrust",

        "title": "Show Trust Report",

        "category": "OxygenHub",

        "icon": "$(shield)"

      },

      {

        "command": "oxygenhub.saveAsset",

        "title": "Save Asset\u2026",

        "category": "OxygenHub",

        "icon": "$(cloud-download)"

      },

      {

        "command": "oxygenhub.newRepository",

        "title": "New Repository\u2026",

        "category": "OxygenHub",

        "icon": "$(repo-create)"

      },

      {

        "command": "oxygenhub.markReady",

        "title": "Mark Ready for Review",

        "category": "OxygenHub"

      },

      {

        "command": "oxygenhub.convertToDraft",

        "title": "Convert to Draft",

        "category": "OxygenHub"

      },

      {

        "command": "oxygenhub.landable",

        "title": "Ready to Land\u2026",

        "category": "OxygenHub",

        "icon": "$(pass)"

          "group": "navigation@2"

        },

        {

          "command": "oxygenhub.newDrop",

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