@getpaseo/protocol 0.1.84

package/dist/git-remote.js

@@ -0,0 +1,72 @@
+const GITHUB_HOSTS = new Set(["github.com", "ssh.github.com"]);
+const TRANSPORT_BY_PROTOCOL = {
+    "https:": "https",
+    "http:": "http",
+    "ssh:": "ssh",
+};
+export function parseGitHubRemoteUrl(remoteUrl) {
+    const location = parseGitRemoteLocation(remoteUrl);
+    if (!location || !isGitHubHost(location.host))
+        return null;
+    return parseGitHubRemoteIdentity(location.path);
+}
+export function parseGitRemoteLocation(remoteUrl) {
+    const trimmed = remoteUrl.trim();
+    if (!trimmed)
+        return null;
+    const scpLike = 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;
+    return { transport, host, 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/host-connection-schema.d.ts

@@ -0,0 +1,23 @@
+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>;
+}, "strip", z.ZodTypeAny, {
+    type: "directTcp";
+    id: string;
+    endpoint: string;
+    useTls: boolean;
+    password?: string | undefined;
+}, {
+    type: "directTcp";
+    id: string;
+    endpoint: string;
+    useTls?: boolean | undefined;
+    password?: string | undefined;
+}>;
+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/importable-providers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Providers eligible for "import recent session" discovery. ACP-based
+ * providers (gemini, copilot, generic acp) are excluded because they either
+ * don't expose persisted history quickly or duplicate other providers.
+ */
+export declare const IMPORTABLE_PROVIDERS: readonly ["claude", "codex", "opencode", "pi"];
+//# sourceMappingURL=importable-providers.d.ts.map

package/dist/importable-providers.js

@@ -0,0 +1,7 @@
+/**
+ * Providers eligible for "import recent session" discovery. ACP-based
+ * providers (gemini, copilot, generic acp) are excluded because they either
+ * don't expose persisted history quickly or duplicate other providers.
+ */
+export const IMPORTABLE_PROVIDERS = ["claude", "codex", "opencode", "pi"];
+//# sourceMappingURL=importable-providers.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