pastilhasandClaude Opus 5
e13128846b
headscale leaves the platform. 45 files move to plugins/offscale/ and the
platform stops knowing it exists.
api/router.ts the thin auth-gated proxy, now at /api/offscale
sidecar/ 18 files, the whole headscale contract and its admin keys
db/ schema + queries, offscale_servers
web/ 26 files as panels and a layout — no screen, per the rule
removed from the platform: the hono mount, the `headscale` capability, the
App.tsx route pair, the screen and its barrel, the AppRegistry spread, the
officerdev re-exports, the dock tile, the page-title rule, and both database
barrels. tsgo is clean and nothing references it.
the imports tell the story of what the plugin↔host API actually is. the sidecar
takes @@/sidecar/protocol, @@/sidecar/connect, @@/data-path and
@@/officer-url.mjs; the queries take officerdb/db and officerdb/crypto; the
schema takes officerdb/auth/schema for the one reference a plugin may make; the
web half takes useClient, copyToClipboard, WorkspaceView and TerminalView from
the officerdev barrel. all of it resolves because a plugin lives inside the repo
— no publishing, no version negotiation.
AND IT FOUND A REAL BUG IN THE INSTALLER. createSidecarProxy learns its port
from a one-shot `<name>:server` event and subscribes when the plugin's router is
first imported — at mount. install started the sidecar BEFORE mounting, so the
announcement fired into a void: process online, routes mounted, every request
answering `503 sidecar not available` until something forced a reconnect. it
would have hit every plugin with an http sidecar. `example` never caught it
because it has no listener to announce.
install and enable now mount before starting; disable still unmounts before
stopping. neither direction leaves a mounted route in front of a sidecar that
cannot be reached.
verified live: /api/offscale/_officer/servers answers {"servers":[]}, /offscale
and /offscale/nodes serve, the old /api/headscale is 404, the offscale
capability is registered from the manifest, and officer-offscale is online.
757 pass, same 10 pre-existing failures.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
78 lines
2.8 KiB
TypeScript
78 lines
2.8 KiB
TypeScript
// A line diff, for showing what a proposed policy actually changes before anyone saves it.
|
|
//
|
|
// Hand-rolled rather than a dependency: this is one screen showing one document, the inputs are a few
|
|
// hundred lines at most, and the alternative is adding a package to the frozen lockfile for forty lines of
|
|
// well-understood algorithm. If a second surface ever needs a diff, that trade flips.
|
|
|
|
export type DiffLine = { kind: 'same' | 'add' | 'remove'; text: string };
|
|
|
|
/** Longest common subsequence table over the two line arrays. O(n·m) — fine at document scale. */
|
|
function lcsLengths(a: string[], b: string[]): number[][] {
|
|
const table: number[][] = Array.from({ length: a.length + 1 }, () => new Array<number>(b.length + 1).fill(0));
|
|
for (let i = a.length - 1; i >= 0; i--) {
|
|
for (let j = b.length - 1; j >= 0; j--) {
|
|
table[i]![j] = a[i] === b[j] ? table[i + 1]![j + 1]! + 1 : Math.max(table[i + 1]![j]!, table[i]![j + 1]!);
|
|
}
|
|
}
|
|
return table;
|
|
}
|
|
|
|
/** Every line of both documents, in order, tagged with what happened to it. */
|
|
export function diffLines(before: string, after: string): DiffLine[] {
|
|
const a = before.split('\n');
|
|
const b = after.split('\n');
|
|
const table = lcsLengths(a, b);
|
|
|
|
const out: DiffLine[] = [];
|
|
let i = 0;
|
|
let j = 0;
|
|
while (i < a.length && j < b.length) {
|
|
if (a[i] === b[j]) {
|
|
out.push({ kind: 'same', text: a[i]! });
|
|
i++;
|
|
j++;
|
|
} else if (table[i + 1]![j]! >= table[i]![j + 1]!) {
|
|
out.push({ kind: 'remove', text: a[i]! });
|
|
i++;
|
|
} else {
|
|
out.push({ kind: 'add', text: b[j]! });
|
|
j++;
|
|
}
|
|
}
|
|
while (i < a.length) out.push({ kind: 'remove', text: a[i++]! });
|
|
while (j < b.length) out.push({ kind: 'add', text: b[j++]! });
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* Drop long runs of unchanged lines, keeping `context` either side of every change.
|
|
*
|
|
* A policy is mostly unchanged by any one edit, and an unabridged diff buries the three lines that matter.
|
|
* `null` marks each elision so the view can draw a gap rather than pretend the lines are adjacent.
|
|
*/
|
|
export function collapseUnchanged(lines: DiffLine[], context = 3): (DiffLine | null)[] {
|
|
const keep = new Array<boolean>(lines.length).fill(false);
|
|
lines.forEach((line, index) => {
|
|
if (line.kind === 'same') return;
|
|
for (let k = Math.max(0, index - context); k <= Math.min(lines.length - 1, index + context); k++) keep[k] = true;
|
|
});
|
|
|
|
const out: (DiffLine | null)[] = [];
|
|
let gap = false;
|
|
lines.forEach((line, index) => {
|
|
if (keep[index]) {
|
|
out.push(line);
|
|
gap = false;
|
|
} else if (!gap) {
|
|
out.push(null);
|
|
gap = true;
|
|
}
|
|
});
|
|
return out;
|
|
}
|
|
|
|
export const diffCounts = (lines: DiffLine[]) => ({
|
|
added: lines.filter((l) => l.kind === 'add').length,
|
|
removed: lines.filter((l) => l.kind === 'remove').length,
|
|
});
|