@aefree/pi-plastic 0.7.6 → 0.8.0

package/src/domain/copied-merge.ts

@@ -0,0 +1,42 @@
+import { win32 } from "node:path";
+import { parseSwitchLoadedBranch, parseSwitchTarget, safeSwitchValue } from "./switch-contract";
+
+/** Observed Windows CM copied-add profile only. No generic pending/parser migration. */
+export const copiedPendingArgv = ["status", "--machinereadable", "--includeRevId", "--fieldseparator=\x1f"];
+const positive = /^[1-9][0-9]{0,19}$/;
+const qualifiedPath = (p: string) => /^(?:[A-Za-z]:[\\/]|\\\\[^\\/]+[\\/][^\\/]+[\\/])/.test(p);
+export const copiedPathKey = (path: string) => win32.normalize(path).toLowerCase();
+export type CopiedPending = { changeset: string; repository: string; server: string; mergeChangeset: string; paths: string[] };
+export function parseCopiedPending(text: string, cwd: string): CopiedPending | null {
+    const lines = text.split(/\r?\n/); if (lines.at(-1) === "") lines.pop();
+    if (lines.length < 2 || lines.length > 129 || Buffer.byteLength(text, "utf8") > 65536 || !qualifiedPath(cwd)) return null;
+    const h = lines[0].split("\x1f");
+    if (h.length !== 4 || h[0] !== "STATUS" || !/^(0|[1-9][0-9]{0,19})$/.test(h[1]) || !h.slice(2).every(v => safeSwitchValue(v) && !/[?\uFFFD]/u.test(v))) return null;
+    const paths: string[] = []; let mergeChangeset = "";
+    for (const line of lines.slice(1)) {
+        const f = line.split("\x1f"), m = /^Merge from ([1-9][0-9]{0,19})$/.exec(f[4] ?? "");
+        if (f.length !== 5 || f[0] !== "CP" || !safeSwitchValue(f[1]) || /[?\uFFFD]/u.test(f[1]) || !qualifiedPath(f[1]) || f[2] !== "False" || !positive.test(f[3]) || !m) return null;
+        const relative = win32.relative(cwd, f[1]);
+        if (!relative || relative === ".." || relative.startsWith("..\\") || win32.isAbsolute(relative) || paths.some(p => copiedPathKey(p) === copiedPathKey(f[1]))) return null;
+        if (mergeChangeset && mergeChangeset !== m[1]) return null;
+        mergeChangeset = m[1]; paths.push(f[1]);
+    }
+    return { changeset: h[1], repository: h[2], server: h[3], mergeChangeset, paths };
+}
+const escape = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Full status is checked for *only* the sourced link/Added/copied rows. Volatile
+ * size/time columns are opaque display, never facts or identities. Unknown sections
+ * (including in-progress/conflict hints), duplicate paths/links and mixed copies fail. */
+export function admitCopiedStandardStatus(text: string, pending: CopiedPending, source: string, cwd: string): boolean {
+    const lines = text.split(/\r?\n/).filter(l => l.trim() !== ""), branch = parseSwitchLoadedBranch(text), requested = parseSwitchTarget(source);
+    if (!branch || !requested || branch.repository !== pending.repository || branch.server !== pending.server || !lines[0].endsWith(`(cs:${pending.changeset} - head)`) || lines.length !== pending.paths.length + 5 || lines[1] !== "Pending merge links" || lines[3] !== "Added" || !/^    Status +Size +Last Modified +Path *$/.test(lines[4])) return false;
+    const link = /^    Merge from cs:([1-9][0-9]{0,19}) at (.+)$/.exec(lines[2]), linked = link && parseSwitchTarget(link[2]);
+    if (!link || link[1] !== pending.mergeChangeset || !linked || linked.branch !== requested.branch || linked.repository !== pending.repository || linked.server !== pending.server || requested.repository !== null && (requested.repository !== linked.repository || requested.server !== linked.server)) return false;
+    const remaining = new Set(pending.paths.map(p => win32.relative(cwd, p)));
+    for (const row of lines.slice(5)) {
+        const candidates = [...remaining].filter(path => new RegExp(`^    Copied \\(new\\) \\(Merge from ${pending.mergeChangeset}\\) {2,}[0-9]+ bytes {2,}[^\\r\\n\\x00-\\x1f\\x7f]{1,128}? {2,}${escape(path)} *$`).test(row));
+        if (candidates.length !== 1) return false;
+        remaining.delete(candidates[0]);
+    }
+    return remaining.size === 0;
+}

package/src/domain/diff-base-xml.ts

@@ -0,0 +1,65 @@
+import { DOMParser, type Element } from "@xmldom/xmldom";
+
+export class DiffBaseXmlError extends Error { constructor() { super("Loaded-file XML did not match the diff source contract."); } }
+function invalid(): never { throw new DiffBaseXmlError(); }
+export function parseDiffXml(bytes: Uint8Array, rootName: string): Element {
+    if (bytes.byteLength > 1048576) invalid();
+    let text: string;
+    try { text = new TextDecoder("utf-8", { fatal:true }).decode(bytes); } catch { return invalid(); }
+    if (!/^<\?xml\s+version=["']1\.0["']\s+encoding=["']utf-8["']\s*\?>/i.test(text) || /<!DOCTYPE|<!ENTITY/i.test(text)) invalid();
+    let document;
+    try { document = new DOMParser({ locator:false, onError:invalid }).parseFromString(text,"application/xml"); } catch { return invalid(); }
+    const root = document.documentElement;
+    if (!root || root.tagName !== rootName || document.doctype) invalid();
+    const stack: Array<[Element,number]> = [[root,1]];
+    let count=0;
+    while(stack.length) {
+        const [e,depth]=stack.pop()!;
+        if (++count>20000 || depth>32 || e.attributes.length || e.namespaceURI) invalid();
+        let length=0;
+        for(let n=e.firstChild;n;n=n.nextSibling) {
+            if(n.nodeType===1) stack.push([n as Element,depth+1]);
+            else if(n.nodeType===3 || n.nodeType===4) length+=(n.nodeValue??"").length;
+            else if(n.nodeType!==8) invalid();
+        }
+        if(length>8192) invalid();
+    }
+    return root;
+}
+export function diffXmlChildren(e:Element, allowed:ReadonlySet<string>):Map<string,Element> {
+    const result=new Map<string,Element>();
+    for(let n=e.firstChild;n;n=n.nextSibling) {
+        if(n.nodeType===1) { const child=n as Element; if(!allowed.has(child.tagName)||result.has(child.tagName)) invalid();result.set(child.tagName,child); }
+        else if(n.nodeType!==8 && (n.nodeValue??"").trim()) invalid();
+    }
+    return result;
+}
+export function diffXmlLeaf(e:Element|undefined):string { if(!e||e.getElementsByTagName("*").length)invalid();return e.textContent??""; }
+const decimal=(s:string)=>{if(!/^(?:0|[1-9][0-9]{0,19})$/.test(s))invalid();return s;};
+const safe=(s:string,empty=false)=>{if((!empty&&!s)||s.length>4096||/[\u0000-\u001f\u007f-\u009f]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(s))invalid();return s;};
+export type LoadedFileInfo={clientPath:string;serverPath:string;changeset:string;hash:string;repSpec:string;status:string;type:string};
+export function parseLoadedFileInfo(bytes:Uint8Array):LoadedFileInfo {
+    const root=parseDiffXml(bytes,"FileInfos");
+    const row=diffXmlChildren(root,new Set(["FileInfo"])).get("FileInfo");if(!row)invalid();
+    const fields=diffXmlChildren(row,new Set(["ClientPath","ServerPath","RevisionChangeset","Hash","RepSpec","Status","Type"]));
+    const get=(name:string)=>diffXmlLeaf(fields.get(name));
+    const result={clientPath:safe(get("ClientPath")),serverPath:safe(get("ServerPath")),changeset:decimal(get("RevisionChangeset")),hash:safe(get("Hash")),repSpec:safe(get("RepSpec"),true),status:safe(get("Status")),type:safe(get("Type"))};
+    if(!result.serverPath.startsWith("/") || !/^[A-Za-z0-9+/]+={0,2}$/.test(result.hash))invalid();
+    return result;
+}
+export type LoadedLsItem={path:string;revisionId:string;changeset:string;hash:string;algorithm:"md5"|"sha1";repository:string;server:string;type:string};
+export function parseLoadedLs(bytes:Uint8Array):LoadedLsItem {
+    const root=parseDiffXml(bytes,"LsResults");
+    const container=diffXmlChildren(root,new Set(["LsItems"])).get("LsItems");if(!container)invalid();
+    const row=diffXmlChildren(container,new Set(["LsItem"])).get("LsItem");if(!row)invalid();
+    const allowed=new Set(["Status","Name","CurrentPath","WkPath","Size","FormattedSize","Type","Changeset","Repository","Owner","Checkout","BrId","RevId","ParentRevId","ItemId","RepId","Server","SymlinkTarget","Hash","HashAlgorithm","Chmod","Branch","Guid","ItemGuid","Date"]);
+    const fields=diffXmlChildren(row,allowed);for(const e of fields.values())diffXmlLeaf(e);
+    const get=(name:string)=>diffXmlLeaf(fields.get(name));
+    const server=safe(get("Server")),spec=safe(get("Repository"));
+    if(!spec.startsWith("rep:") || !spec.endsWith("@"+server))invalid();
+    const repository=spec.slice(4,-server.length-1);safe(repository);if(repository.includes("@"))invalid();
+    const algorithm=get("HashAlgorithm").toLowerCase();if(algorithm!=="md5"&&algorithm!=="sha1")invalid();
+    const result:LoadedLsItem={path:safe(get("CurrentPath")),revisionId:decimal(get("RevId")),changeset:decimal(get("Changeset")),hash:safe(get("Hash")),algorithm,repository,server,type:safe(get("Type"))};
+    if(!/^[A-Za-z0-9+/]+={0,2}$/.test(result.hash))invalid();
+    return result;
+}

package/src/domain/diff-pending-xml.ts

@@ -0,0 +1,34 @@
+import type { Element } from "@xmldom/xmldom";
+import { parseDiffXml, diffXmlChildren, diffXmlLeaf, DiffBaseXmlError } from "./diff-base-xml";
+export type DiffPendingKind="changed"|"added"|"deleted"|"moved"|"private"|"checkedout"|"copied"|"replaced";
+export type DiffPendingItem={path:string;sourcePath:string|null;kind:DiffPendingKind;code:string;directory:boolean};
+export type DiffPendingSnapshot={items:DiffPendingItem[];repository:string;server:string;changeset:string};
+const kinds={CH:"changed",AD:"added",DE:"deleted",LD:"deleted",MV:"moved",LM:"moved",PR:"private",CO:"checkedout","CO+CH":"changed",CP:"copied",RP:"replaced"} as const;
+function invalid():never {throw new DiffBaseXmlError();}
+const text=(e:Element|undefined)=>diffXmlLeaf(e);
+const path=(s:string)=>{if(!s||s.length>4096||!(/^[A-Za-z]:[\\/]/.test(s)||s.startsWith("/"))||/[\u0000-\u001f\u007f-\u009f]/.test(s)||(process.platform==="win32"&&s.includes("?")))invalid();return s;};
+export function parseDiffPending(bytes:Uint8Array):DiffPendingSnapshot {
+    const root=diffXmlChildren(parseDiffXml(bytes,"StatusOutput"),new Set(["WorkspaceStatus","WkConfigType","WkConfigName","Changes"]));
+    if(!text(root.get("WkConfigType"))||!text(root.get("WkConfigName")))invalid();
+    const workspace=root.get("WorkspaceStatus");if(!workspace)invalid();
+    const status=diffXmlChildren(workspace,new Set(["Status"])).get("Status");if(!status)invalid();
+    const context=diffXmlChildren(status,new Set(["RepSpec","Changeset"]));
+    const rep=context.get("RepSpec");if(!rep)invalid();
+    const identity=diffXmlChildren(rep,new Set(["Server","Name"]));
+    const repository=text(identity.get("Name")),server=text(identity.get("Server")),changeset=text(context.get("Changeset"));
+    if(!repository||!server||! /^(?:0|[1-9][0-9]{0,19})$/.test(changeset)||/[;\u0000-\u001f\u007f-\u009f]/.test(repository+server)||repository.includes("@"))invalid();
+    const items:DiffPendingItem[]=[],seen=new Set<string>();
+    const changes=root.get("Changes");
+    const allowed=new Set(["Type","TypeVerbose","Path","OldPath","PrintableMovedPath","MergesInfo","SimilarityPerUnit","Similarity","Size","PrintableSize","PrintableLastModified","RevisionType","LastModified"]);
+    if(changes)for(let n=changes.firstChild;n;n=n.nextSibling) {
+        if(n.nodeType!==1){if(n.nodeType!==8&&(n.nodeValue??"").trim())invalid();continue;}
+        const e=n as Element;if(e.tagName!=="Change"||items.length>=20000)invalid();
+        const fields=diffXmlChildren(e,allowed);for(const e of fields.values())text(e);
+        const code=text(fields.get("Type"));if(!Object.hasOwn(kinds,code))invalid();
+        const kind=kinds[code as keyof typeof kinds],p=path(text(fields.get("Path"))),old=text(fields.get("OldPath")),revisionType=text(fields.get("RevisionType"));
+        if((kind==="moved")!==Boolean(old)||old&&path(old)===p||seen.has(p))invalid();seen.add(p);
+        if(revisionType!=="enDirectory"&&revisionType!=="enTextFile"&&revisionType!=="enBinaryFile")invalid();
+        items.push({path:p,sourcePath:old||null,kind,code,directory:revisionType==="enDirectory"});
+    }
+    return {items,repository,server,changeset};
+}

package/src/domain/merge-output.ts

@@ -0,0 +1,327 @@
+import { normalizeFindOutputLines } from "../execution/cm";
+import { splitServerBranch, type ServerChangeset } from "./server-merge-contract";
+
+export type MergeStatusSummary = {
+    hasPendingMergeLinks: boolean;
+    pendingMergeLinks: string[];
+    mergeInProgressHints: string[];
+    hasMergeInProgress: boolean;
+};
+
+export const analyzeMergeStatusOutput = (output: string): MergeStatusSummary =>
+{
+    const lines = normalizeFindOutputLines(output);
+    const pendingMergeLinks: string[] = [];
+    const mergeInProgressHints: string[] = [];
+    let inPendingMergeLinksSection = false;
+
+    for (const line of lines)
+    {
+        const trimmed = line.trim();
+        const normalized = trimmed.toLowerCase();
+
+        if (normalized === "pending merge links")
+        {
+            inPendingMergeLinksSection = true;
+            continue;
+        }
+
+        if (inPendingMergeLinksSection)
+        {
+            if (trimmed.length === 0)
+            {
+                continue;
+            }
+
+            if (/^(changed|added|deleted|moved|private|controlled changes|items changed|local changes)\b/i.test(trimmed))
+            {
+                inPendingMergeLinksSection = false;
+            }
+            else if (/^merge\s+from\b/i.test(trimmed))
+            {
+                pendingMergeLinks.push(trimmed);
+                continue;
+            }
+        }
+
+        if (/merge\s+in\s+progress|finish\s+it\s+before\s+checkin|unresolved\s+merge|pending\s+conflicts/i.test(trimmed))
+        {
+            mergeInProgressHints.push(trimmed);
+        }
+    }
+
+    return {
+        hasPendingMergeLinks: pendingMergeLinks.length > 0,
+        pendingMergeLinks,
+        mergeInProgressHints,
+        hasMergeInProgress: mergeInProgressHints.length > 0,
+    };
+};
+
+export type MergeMachineReadableRecord = {
+    raw: string;
+    fields: string[];
+    operation: string;
+};
+
+export type MergeOutputSummary = {
+    recordCount: number;
+    conflictSignals: string[];
+    unresolvedSignals: string[];
+    warningSignals: string[];
+    fileConflictSignals: string[];
+    fileConflictPaths: string[];
+};
+
+export const MERGE_START_LINE_SEPARATOR = "__OC_MR_START__";
+export const MERGE_END_LINE_SEPARATOR = "__OC_MR_END__";
+export const MERGE_FIELD_SEPARATOR = "__OC_MR_FIELD__";
+
+export const mergeConflictSignalPattern = /\b(conflict|eviltwin|changedelete|deletechange|movedelete|deletemove|loadedtwice|addmove|moveadd|divergentmove|cyclemove|movedeviltwin)\b/i;
+export const mergeUnresolvedSignalPattern = /\b(unresolved|cannot\s+resolve|can't\s+resolve|manual\s+conflict|not\s+solved|failed\s+to\s+resolve)\b/i;
+export const mergeWarningSignalPattern = /\bwarn(?:ing)?\b/i;
+export const mergeFileConflictOperation = "FILE_CONFLICT";
+
+export const escapeRegex = (value: string): string => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+export const normalizeErrorMessage = (error: unknown): string =>
+{
+    if (error instanceof Error)
+    {
+        return error.message;
+    }
+
+    return String(error ?? "Unknown error");
+};
+
+export const parseMergeMachineReadableRecords = (output: string): MergeMachineReadableRecord[] =>
+{
+    const pattern = new RegExp(`${escapeRegex(MERGE_START_LINE_SEPARATOR)}([\\s\\S]*?)${escapeRegex(MERGE_END_LINE_SEPARATOR)}`, "g");
+    const records: MergeMachineReadableRecord[] = [];
+
+    for (const match of output.matchAll(pattern))
+    {
+        const raw = String(match[1] ?? "").trim();
+        if (!raw)
+        {
+            continue;
+        }
+
+        const fields = raw
+            .split(MERGE_FIELD_SEPARATOR)
+            .map((field) => field.trim())
+            .filter((field) => field.length > 0);
+        const operation = fields[0] ?? "";
+        records.push({
+            raw,
+            fields,
+            operation,
+        });
+    }
+
+    return records;
+};
+
+export const summarizeMergeOutput = (output: string): MergeOutputSummary =>
+{
+    const records = parseMergeMachineReadableRecords(output);
+    const textLines = normalizeFindOutputLines(output);
+    const conflictSignals = new Set<string>();
+    const unresolvedSignals = new Set<string>();
+    const warningSignals = new Set<string>();
+    const fileConflictSignals = new Set<string>();
+    const fileConflictPaths = new Set<string>();
+
+    for (const record of records)
+    {
+        const mergedText = record.fields.join(" ");
+        const isFileConflict = record.operation.toUpperCase() === mergeFileConflictOperation;
+
+        if (isFileConflict)
+        {
+            conflictSignals.add(record.raw);
+            unresolvedSignals.add(record.raw);
+            fileConflictSignals.add(record.raw);
+            if (record.fields[1])
+            {
+                fileConflictPaths.add(record.fields[1]);
+            }
+        }
+        else if (mergeConflictSignalPattern.test(mergedText))
+        {
+            conflictSignals.add(record.raw);
+        }
+
+        if (mergeUnresolvedSignalPattern.test(mergedText))
+        {
+            unresolvedSignals.add(record.raw);
+        }
+
+        if (record.operation.toUpperCase().includes("WARN") || mergeWarningSignalPattern.test(mergedText))
+        {
+            warningSignals.add(record.raw);
+        }
+    }
+
+    for (const line of textLines)
+    {
+        if (/\bFILE_CONFLICT\b/i.test(line))
+        {
+            conflictSignals.add(line);
+            unresolvedSignals.add(line);
+            fileConflictSignals.add(line);
+        }
+        else if (mergeConflictSignalPattern.test(line))
+        {
+            conflictSignals.add(line);
+        }
+
+        if (mergeUnresolvedSignalPattern.test(line))
+        {
+            unresolvedSignals.add(line);
+        }
+
+        if (/DIS_OP_WARN|\bwarn(?:ing)?\b/i.test(line))
+        {
+            warningSignals.add(line);
+        }
+    }
+
+    return {
+        recordCount: records.length,
+        conflictSignals: Array.from(conflictSignals),
+        unresolvedSignals: Array.from(unresolvedSignals),
+        warningSignals: Array.from(warningSignals),
+        fileConflictSignals: Array.from(fileConflictSignals),
+        fileConflictPaths: Array.from(fileConflictPaths),
+    };
+};
+
+export type ServerMergeRecord = {
+    operation: string;
+    fields: string[];
+};
+
+export type ServerMergeParse = {
+    records: ServerMergeRecord[];
+    malformed: boolean;
+    unknownOperations: string[];
+    changesets: ServerChangeset[];
+    isAlreadyConnected: boolean;
+    hasConflict: boolean;
+};
+
+export const parseServerMergeOutput = (output: string, separators: { start: string; end: string; field: string }): ServerMergeParse =>
+{
+    const records: ServerMergeRecord[] = [];
+    const unknownOperations = new Set<string>();
+    let malformed = false;
+    let cursor = 0;
+
+    while (true)
+    {
+        const start = output.indexOf(separators.start, cursor);
+        if (start < 0)
+        {
+            if (output.slice(cursor).trim() !== "")
+            {
+                malformed = true;
+            }
+            break;
+        }
+        const prefix = output.slice(cursor, start);
+        if (prefix.trim() !== "")
+        {
+            malformed = true;
+        }
+        const payloadStart = start + separators.start.length;
+        const end = output.indexOf(separators.end, payloadStart);
+        if (end < 0)
+        {
+            malformed = true;
+            break;
+        }
+        const payload = output.slice(payloadStart, end);
+        if (!payload || payload.includes(separators.start) || payload.includes(separators.end))
+        {
+            malformed = true;
+        }
+        else
+        {
+            const fields = payload.split(separators.field);
+            if (records.length >= 500) { malformed = true; break; }
+            const operation = fields[0] ?? "";
+            if (!operation || fields.some((field) => field.length === 0))
+            {
+                malformed = true;
+            }
+            else
+            {
+                records.push({ operation, fields });
+                if (!["FILE_SRC", "CHANGESET", "STATUS", "FILE_CONFLICT"].includes(operation))
+                {
+                    unknownOperations.add(operation);
+                    malformed = true;
+                }
+            }
+        }
+        cursor = end + separators.end.length;
+    }
+
+    const changesets: ServerChangeset[] = [];
+    const decimal = (s: string) => /^(0|[1-9][0-9]{0,19})$/.test(s);
+    const safe = (s: string) => s.length <= 4096 && !/[\u0000-\u001f\u007f-\u009f]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(s);
+    let isAlreadyConnected = false;
+    let hasConflict = false;
+    for (const record of records)
+    {
+        switch (record.operation)
+        {
+            case "FILE_SRC":
+                if (record.fields.length !== 5 || !record.fields[1]?.startsWith("/") || !record.fields.slice(2).every(decimal) || !safe(record.fields[1]!))
+                {
+                    malformed = true;
+                }
+                break;
+            case "CHANGESET":
+            {
+                if (record.fields.length !== 2)
+                {
+                    malformed = true;
+                    break;
+                }
+                const match = record.fields[1]?.match(/^cs:([^@]+)@(.+) \(mount:'([^']+)'\)$/);
+                const identity = match ? splitServerBranch("br:" + match[2]) : null;
+                if (!match || !identity || !decimal(match[1]!) || !safe(record.fields[1]!) || !safe(match[3]!))
+                {
+                    malformed = true;
+                    break;
+                }
+                changesets.push({
+                    id: match[1]!,
+                    ...identity,
+                    mount: match[3]!,
+                });
+                break;
+            }
+            case "STATUS":
+                if (record.fields.length !== 3 || record.fields[1] !== "ALREADY_CONNECTED" || record.fields[2] !== "No merges detected" || isAlreadyConnected)
+                {
+                    malformed = true;
+                }
+                isAlreadyConnected = true;
+                break;
+            case "FILE_CONFLICT":
+                if (record.fields.length !== 6 || !record.fields[1]?.startsWith("/") || !record.fields.slice(2).every(decimal) || !safe(record.fields[1]!))
+                {
+                    malformed = true;
+                }
+                hasConflict = true;
+                break;
+            default:
+                // Unknown operations were recorded above and make the response uncertain.
+                break;
+        }
+    }
+    return { records, malformed, unknownOperations: [...unknownOperations], changesets, isAlreadyConnected, hasConflict };
+};