@camerontaylor/paseo-protocol 0.8.0-fork.1

package/dist/git-remote.d.ts

@@ -0,0 +1,33 @@
+export interface GitRemoteLocation {
+    transport: "scp" | "ssh" | "http" | "https";
+    host: string;
+    /**
+     * Explicit non-default port from the remote (e.g. a self-hosted forge on
+     * `:60443`), or undefined for a default-port or scp-form remote. Kept separate
+     * from `host` so host-identity matching (forge detection, cloud-host checks)
+     * stays port-agnostic; only consumers that reconstruct a URL (web links) use it.
+     */
+    port?: string;
+    path: string;
+}
+export interface GitHubRemoteIdentity {
+    owner: string;
+    name: string;
+    repo: string;
+}
+export declare function parseGitHubRemoteUrl(remoteUrl: string): GitHubRemoteIdentity | null;
+/**
+ * Whether `repo` is already a complete git remote (a URL or scp-like address)
+ * rather than `owner/repo` shorthand that still needs a clone protocol picked.
+ *
+ * Clients (app + CLI) and the daemon must agree on this classification: the
+ * daemon treats `parseGitRemoteLocation(repo) !== null` as "complete remote"
+ * and everything else as shorthand, so reuse the same parser here instead of a
+ * separate regex that would drift (e.g. accepting `git://` the parser rejects).
+ */
+export declare function isCompleteGitRemote(repo: string): boolean;
+export declare function parseGitRemoteLocation(remoteUrl: string): GitRemoteLocation | null;
+export declare function parseGitHubRemoteIdentity(path: string): GitHubRemoteIdentity | null;
+export declare function isGitHubHost(host: string): boolean;
+export declare function normalizeHost(host: string): string;
+//# sourceMappingURL=git-remote.d.ts.map

package/dist/git-remote.js

@@ -0,0 +1,94 @@
+import { getForgeDefinition } from "./forge-manifest.js";
+const GITHUB_HOSTS = new Set(getForgeDefinition("github")?.cloudHosts ?? []);
+const TRANSPORT_BY_PROTOCOL = {
+    "https:": "https",
+    "http:": "http",
+    "ssh:": "ssh",
+};
+const DEFAULT_PORT_BY_PROTOCOL = {
+    "https:": "443",
+    "http:": "80",
+    "ssh:": "22",
+};
+export function parseGitHubRemoteUrl(remoteUrl) {
+    const location = parseGitRemoteLocation(remoteUrl);
+    if (!location || !isGitHubHost(location.host))
+        return null;
+    return parseGitHubRemoteIdentity(location.path);
+}
+/**
+ * Whether `repo` is already a complete git remote (a URL or scp-like address)
+ * rather than `owner/repo` shorthand that still needs a clone protocol picked.
+ *
+ * Clients (app + CLI) and the daemon must agree on this classification: the
+ * daemon treats `parseGitRemoteLocation(repo) !== null` as "complete remote"
+ * and everything else as shorthand, so reuse the same parser here instead of a
+ * separate regex that would drift (e.g. accepting `git://` the parser rejects).
+ */
+export function isCompleteGitRemote(repo) {
+    return parseGitRemoteLocation(repo) !== null;
+}
+export function parseGitRemoteLocation(remoteUrl) {
+    const trimmed = remoteUrl.trim();
+    if (!trimmed)
+        return null;
+    // scp form has no scheme. Testing it first would match `ssh://git@host:22/x`
+    // — `[^@]+` happily eats `ssh://git` — and swallow the port into the path.
+    const scpLike = trimmed.includes("://") ? null : trimmed.match(/^[^@]+@([^:]+):(.+)$/u);
+    if (scpLike) {
+        const host = normalizeHost(scpLike[1] ?? "");
+        const path = normalizeRemotePath(scpLike[2] ?? "");
+        if (!isValidRemoteHost(host) || !path)
+            return null;
+        return { transport: "scp", host, path };
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return null;
+    }
+    const transport = TRANSPORT_BY_PROTOCOL[parsed.protocol.toLowerCase()];
+    if (!transport)
+        return null;
+    const host = normalizeHost(parsed.hostname);
+    let path;
+    try {
+        path = decodeURIComponent(parsed.pathname);
+    }
+    catch {
+        return null;
+    }
+    const normalizedPath = normalizeRemotePath(path);
+    if (!isValidRemoteHost(host) || !normalizedPath)
+        return null;
+    const protocol = parsed.protocol.toLowerCase();
+    const port = parsed.port && parsed.port !== DEFAULT_PORT_BY_PROTOCOL[protocol] ? parsed.port : undefined;
+    return { transport, host, port, path: normalizedPath };
+}
+export function parseGitHubRemoteIdentity(path) {
+    const segments = path.split("/").filter(Boolean);
+    if (segments.length !== 2)
+        return null;
+    const [owner, name] = segments;
+    if (!owner || !name)
+        return null;
+    return { owner, name, repo: `${owner}/${name}` };
+}
+export function isGitHubHost(host) {
+    return GITHUB_HOSTS.has(host);
+}
+export function normalizeHost(host) {
+    return host.trim().replace(/\.+$/u, "").toLowerCase();
+}
+function normalizeRemotePath(path) {
+    let normalized = path.trim().replace(/^\/+|\/+$/gu, "");
+    if (normalized.endsWith(".git"))
+        normalized = normalized.slice(0, -4);
+    return normalized || null;
+}
+function isValidRemoteHost(host) {
+    return /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/u.test(host);
+}
+//# sourceMappingURL=git-remote.js.map

package/dist/gitea-status.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Maps a Gitea/Forgejo commit-status state (individual status or the combined
+ * aggregate, e.g. a forge fact's ciStatus) onto the neutral check status.
+ * Shared by the daemon's Gitea adapter and the app's Gitea forge module so the
+ * "warning is terminal and non-passing" rule lives in one place: upstream
+ * treats warning as IsSuccess() == false, so it blocks merges and must not
+ * render as a plain pass or hang as pending.
+ */
+export declare function mapGiteaCommitState(state: string): "success" | "failure" | "pending" | "skipped";
+//# sourceMappingURL=gitea-status.d.ts.map

package/dist/gitea-status.js

@@ -0,0 +1,23 @@
+/**
+ * Maps a Gitea/Forgejo commit-status state (individual status or the combined
+ * aggregate, e.g. a forge fact's ciStatus) onto the neutral check status.
+ * Shared by the daemon's Gitea adapter and the app's Gitea forge module so the
+ * "warning is terminal and non-passing" rule lives in one place: upstream
+ * treats warning as IsSuccess() == false, so it blocks merges and must not
+ * render as a plain pass or hang as pending.
+ */
+export function mapGiteaCommitState(state) {
+    switch (state.toLowerCase()) {
+        case "success":
+            return "success";
+        case "failure":
+        case "error":
+        case "warning":
+            return "failure";
+        case "skipped":
+            return "skipped";
+        default:
+            return "pending";
+    }
+}
+//# sourceMappingURL=gitea-status.js.map

package/dist/gitlab-pipeline.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Canonical set of GitLab pipeline/job statuses that count as "still active"
+ * (not yet terminal). Shared by the daemon (merge-capability facts, checks
+ * aggregation) and the app (pipeline presentation) so a new GitLab transitional
+ * status only needs to be added in one place.
+ */
+export declare const GITLAB_ACTIVE_PIPELINE_STATUSES: readonly ["created", "waiting_for_resource", "preparing", "pending", "running", "canceling", "scheduled"];
+export type GitLabActivePipelineStatus = (typeof GITLAB_ACTIVE_PIPELINE_STATUSES)[number];
+export declare const GITLAB_ACTIVE_PIPELINE_STATUS_SET: Set<string>;
+//# sourceMappingURL=gitlab-pipeline.d.ts.map

package/dist/gitlab-pipeline.js

@@ -0,0 +1,17 @@
+/**
+ * Canonical set of GitLab pipeline/job statuses that count as "still active"
+ * (not yet terminal). Shared by the daemon (merge-capability facts, checks
+ * aggregation) and the app (pipeline presentation) so a new GitLab transitional
+ * status only needs to be added in one place.
+ */
+export const GITLAB_ACTIVE_PIPELINE_STATUSES = [
+    "created",
+    "waiting_for_resource",
+    "preparing",
+    "pending",
+    "running",
+    "canceling",
+    "scheduled",
+];
+export const GITLAB_ACTIVE_PIPELINE_STATUS_SET = new Set(GITLAB_ACTIVE_PIPELINE_STATUSES);
+//# sourceMappingURL=gitlab-pipeline.js.map

package/dist/host-connection-schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const DirectTcpHostConnectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"directTcp">;
+    endpoint: z.ZodString;
+    useTls: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    password: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DirectTcpHostConnection = z.input<typeof DirectTcpHostConnectionSchema>;
+export type NormalizedDirectTcpHostConnection = z.output<typeof DirectTcpHostConnectionSchema>;
+//# sourceMappingURL=host-connection-schema.d.ts.map

package/dist/host-connection-schema.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const DirectTcpHostConnectionSchema = z.object({
+    id: z.string(),
+    type: z.literal("directTcp"),
+    endpoint: z.string(),
+    useTls: z.boolean().optional().default(false),
+    password: z.string().optional(),
+});
+//# sourceMappingURL=host-connection-schema.js.map

package/dist/literal-union.d.ts

@@ -0,0 +1,2 @@
+export type LiteralUnion<T extends U, U extends string> = T | (U & Record<never, never>);
+//# sourceMappingURL=literal-union.d.ts.map

package/dist/literal-union.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=literal-union.js.map