threadlog 0.1.0

package/LICENSE

@@ -0,0 +1,3 @@
+© Threadlog. All rights reserved.
+
+Use is subject to Threadlog Commercial Terms of Service.

package/README.md

@@ -0,0 +1,67 @@
+# Threadlog CLI
+
+`threadlog` uploads local Codex and Claude sessions to Threadlog.
+
+## Requirements
+
+- Node.js `>=20`
+- macOS or Linux
+- a system keyring
+  - macOS: Keychain via `security`
+  - Linux: Secret Service via `secret-tool`
+- a Threadlog account
+
+## Install
+
+```sh
+npm install -g threadlog
+```
+
+Or run with `npx`
+
+```sh
+npx threadlog --help
+```
+
+## First Use
+
+Log in once with a personal access token:
+
+```sh
+threadlog login
+```
+
+You can also pass the token explicitly:
+
+```sh
+threadlog login --token tl_pat_xxx
+```
+
+By default the CLI targets production:
+
+- API: `https://api.threadlog.dev`
+- app: `https://app.threadlog.dev`
+
+## Share Sessions
+
+Interactive Codex picker:
+
+```sh
+threadlog share codex
+```
+
+Interactive Claude picker:
+
+```sh
+threadlog share claude
+```
+
+Explicit file upload:
+
+```sh
+threadlog share codex --file /path/to/rollout.jsonl
+```
+
+```sh
+threadlog share claude --file /path/to/session.jsonl
+```

package/dist/agents/claude/adapter.js

@@ -0,0 +1,147 @@
+import { stat, readdir } from "node:fs/promises";
+import path from "node:path";
+import { buildRedactedRawEventArrayFromJsonl } from "../../thread/canonical.js";
+import { RAW_ARTIFACT_VERSION } from "../types.js";
+import { claudeProjectsDir, discoverClaudeSessions } from "./discovery.js";
+import { readClaudePromptPreviewTitle } from "./title.js";
+export function createClaudeSourceAdapter() {
+    return {
+        source: "claude",
+        label: "Claude",
+        discoverSessions: discoverClaudeSourceSessions,
+        resolveExplicitFilePath,
+        buildUploadInput: buildClaudeUploadInput,
+    };
+}
+async function discoverClaudeSourceSessions(options) {
+    const root = claudeProjectsDir();
+    const sessions = await discoverClaudeSessions({ maxResults: options.maxResults });
+    return Promise.all(sessions.map(async (session) => {
+        const promptPreview = await readClaudePromptPreviewTitle(session.filePath).catch(() => null);
+        const relativePath = path.relative(root, session.filePath) || session.filePath;
+        return {
+            mainFilePath: session.filePath,
+            displayName: promptPreview ?? path.basename(session.filePath),
+            description: `${session.workspaceSlug}  ${relativePath}`,
+            mtimeMs: session.mtimeMs,
+            sizeBytes: session.sizeBytes,
+        };
+    }));
+}
+async function buildClaudeUploadInput(mainFilePath) {
+    const title = await readClaudePromptPreviewTitle(mainFilePath).catch(() => null);
+    const mainEvents = await buildRedactedRawEventArrayFromJsonl(mainFilePath);
+    const capturedAt = extractFirstTimestamp(mainEvents);
+    const files = [
+        {
+            filePath: mainFilePath,
+            fileRole: "main",
+            events: mainEvents,
+            isSidechain: extractFirstBoolean(mainEvents, "isSidechain"),
+            agentId: extractFirstString(mainEvents, "agentId"),
+        },
+    ];
+    const subagentFiles = await discoverSubagentSessionFiles(mainFilePath);
+    for (const subagentFilePath of subagentFiles) {
+        const subagentEvents = await buildRedactedRawEventArrayFromJsonl(subagentFilePath).catch((error) => {
+            if (error instanceof Error && error.message.includes("does not contain any JSONL events")) {
+                return null;
+            }
+            throw error;
+        });
+        if (!subagentEvents || subagentEvents.length === 0) {
+            continue;
+        }
+        const fallbackAgentId = extractAgentIdFromFileName(subagentFilePath);
+        files.push({
+            filePath: subagentFilePath,
+            fileRole: "subagent",
+            events: subagentEvents,
+            isSidechain: extractFirstBoolean(subagentEvents, "isSidechain"),
+            agentId: extractFirstString(subagentEvents, "agentId") ?? fallbackAgentId,
+        });
+    }
+    return {
+        artifact: {
+            rawVersion: RAW_ARTIFACT_VERSION,
+            source: "claude",
+            files,
+        },
+        title: title ?? path.basename(mainFilePath),
+        capturedAt: capturedAt ?? undefined,
+    };
+}
+async function resolveExplicitFilePath(inputPath) {
+    const resolved = path.resolve(inputPath);
+    const fileStats = await stat(resolved).catch((error) => {
+        if (error.code === "ENOENT") {
+            throw new Error(`session file not found: ${resolved}`);
+        }
+        throw error;
+    });
+    if (!fileStats.isFile()) {
+        throw new Error(`session path must be a file: ${resolved}`);
+    }
+    if (!resolved.endsWith(".jsonl")) {
+        throw new Error(`session file must end with .jsonl: ${resolved}`);
+    }
+    return resolved;
+}
+async function discoverSubagentSessionFiles(mainFilePath) {
+    const sessionId = path.basename(mainFilePath, ".jsonl");
+    const subagentsDir = path.join(path.dirname(mainFilePath), sessionId, "subagents");
+    let entries;
+    try {
+        entries = await readdir(subagentsDir, { encoding: "utf8" });
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    return entries
+        .filter((name) => name.endsWith(".jsonl"))
+        .sort((a, b) => a.localeCompare(b))
+        .map((name) => path.join(subagentsDir, name));
+}
+function extractAgentIdFromFileName(filePath) {
+    const match = path.basename(filePath).match(/^agent-(.+)\.jsonl$/);
+    return match?.[1];
+}
+function extractFirstString(events, field) {
+    for (const event of events) {
+        if (!event || typeof event !== "object" || Array.isArray(event)) {
+            continue;
+        }
+        const value = event[field];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function extractFirstBoolean(events, field) {
+    for (const event of events) {
+        if (!event || typeof event !== "object" || Array.isArray(event)) {
+            continue;
+        }
+        const value = event[field];
+        if (typeof value === "boolean") {
+            return value;
+        }
+    }
+    return undefined;
+}
+function extractFirstTimestamp(events) {
+    for (const event of events) {
+        if (!event || typeof event !== "object" || Array.isArray(event)) {
+            continue;
+        }
+        const timestamp = event.timestamp;
+        if (typeof timestamp === "string" && timestamp.trim().length > 0) {
+            return timestamp;
+        }
+    }
+    return null;
+}

package/dist/agents/claude/discovery.js

@@ -0,0 +1,57 @@
+import { readdir, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export function claudeProjectsDir() {
+    const overridden = process.env.CLAUDE_HOME?.trim();
+    if (overridden) {
+        return path.join(path.resolve(overridden), "projects");
+    }
+    return path.join(os.homedir(), ".claude", "projects");
+}
+export async function discoverClaudeSessions(options) {
+    const projectsRoot = options?.projectsRoot
+        ? path.resolve(options.projectsRoot)
+        : claudeProjectsDir();
+    const workspaceSlugs = await readDirs(projectsRoot);
+    const matches = [];
+    for (const slug of workspaceSlugs) {
+        const slugPath = path.join(projectsRoot, slug.name);
+        const entries = await readEntries(slugPath);
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+                continue;
+            }
+            const filePath = path.join(slugPath, entry.name);
+            const fileStats = await stat(filePath);
+            matches.push({
+                filePath,
+                workspaceSlug: slug.name,
+                sizeBytes: fileStats.size,
+                mtimeMs: fileStats.mtimeMs,
+            });
+        }
+    }
+    matches.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    if (!options?.maxResults || options.maxResults <= 0) {
+        return matches;
+    }
+    return matches.slice(0, options.maxResults);
+}
+async function readDirs(rootDir) {
+    const entries = await readEntries(rootDir);
+    return entries.filter((entry) => entry.isDirectory());
+}
+async function readEntries(rootDir) {
+    try {
+        return await readdir(rootDir, {
+            withFileTypes: true,
+            encoding: "utf8",
+        });
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+}

package/dist/agents/claude/title.js

@@ -0,0 +1,91 @@
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { truncateForThreadTitle } from "../../codex/promptPreview.js";
+export async function readClaudePromptPreviewTitle(filePath) {
+    const reader = createInterface({
+        input: createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+    });
+    let fallbackText = null;
+    for await (const rawLine of reader) {
+        const line = rawLine.trim();
+        if (!line) {
+            continue;
+        }
+        const parsed = safeParseRecord(line);
+        if (!parsed) {
+            continue;
+        }
+        const primaryUserMessage = extractPrimaryUserMessage(parsed);
+        if (primaryUserMessage) {
+            return truncateForThreadTitle(primaryUserMessage);
+        }
+        if (!fallbackText) {
+            fallbackText = extractFallbackText(parsed);
+        }
+    }
+    return truncateForThreadTitle(fallbackText);
+}
+function extractPrimaryUserMessage(event) {
+    if (asString(event.type)?.toLowerCase() !== "user") {
+        return null;
+    }
+    return firstNonBlank(extractText(event.message), extractText(event.content), asString(event.text), extractText(event.payload));
+}
+function extractFallbackText(event) {
+    return firstNonBlank(asString(event.type), extractText(event.message), extractText(event.content), asString(event.text), extractText(event.payload));
+}
+function extractText(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    if (Array.isArray(value)) {
+        const joined = value
+            .map((item) => extractText(item))
+            .filter((text) => Boolean(text))
+            .join("\n")
+            .trim();
+        return joined || null;
+    }
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const obj = value;
+    const joined = ["text", "message", "content", "input", "thinking", "summary", "value"]
+        .map((key) => extractText(obj[key]))
+        .filter((text) => Boolean(text))
+        .join("\n")
+        .trim();
+    return joined || null;
+}
+function safeParseRecord(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return asRecord(parsed);
+    }
+    catch {
+        return null;
+    }
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function asString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function firstNonBlank(...values) {
+    for (const value of values) {
+        if (value && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return null;
+}

package/dist/agents/codex/adapter.js

@@ -0,0 +1,64 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { buildRedactedRawEventArrayFromJsonl } from "../../thread/canonical.js";
+import { codexHomeDir, discoverCodexRollouts } from "../../codex/discovery.js";
+import { readCodexRolloutMetadata } from "../../codex/metadata.js";
+import { readCodexPromptPreviewTitle } from "../../codex/promptPreview.js";
+import { RAW_ARTIFACT_VERSION } from "../types.js";
+export function createCodexSourceAdapter() {
+    return {
+        source: "codex",
+        label: "Codex",
+        discoverSessions: discoverCodexSessions,
+        resolveExplicitFilePath,
+        buildUploadInput: buildCodexUploadInput,
+    };
+}
+async function discoverCodexSessions(options) {
+    const codexHome = codexHomeDir();
+    const rollouts = await discoverCodexRollouts({ maxResults: options.maxResults });
+    return Promise.all(rollouts.map(async (rollout) => {
+        const relativePath = path.relative(codexHome, rollout.filePath) || rollout.filePath;
+        const promptPreview = await readCodexPromptPreviewTitle(rollout.filePath).catch(() => null);
+        return {
+            mainFilePath: rollout.filePath,
+            displayName: promptPreview ?? path.basename(rollout.filePath),
+            description: relativePath,
+            mtimeMs: rollout.mtimeMs,
+            sizeBytes: rollout.sizeBytes,
+        };
+    }));
+}
+async function buildCodexUploadInput(mainFilePath) {
+    const metadata = await readCodexRolloutMetadata(mainFilePath);
+    const events = await buildRedactedRawEventArrayFromJsonl(mainFilePath);
+    const title = await readCodexPromptPreviewTitle(mainFilePath).catch(() => null);
+    return {
+        artifact: {
+            rawVersion: RAW_ARTIFACT_VERSION,
+            source: "codex",
+            files: [
+                {
+                    filePath: mainFilePath,
+                    fileRole: "main",
+                    events,
+                },
+            ],
+        },
+        title: title ?? path.basename(mainFilePath),
+        capturedAt: metadata.firstTimestamp ?? undefined,
+    };
+}
+async function resolveExplicitFilePath(inputPath) {
+    const resolved = path.resolve(inputPath);
+    const fileStats = await stat(resolved).catch((error) => {
+        if (error.code === "ENOENT") {
+            throw new Error(`session file not found: ${resolved}`);
+        }
+        throw error;
+    });
+    if (!fileStats.isFile()) {
+        throw new Error(`session path must be a file: ${resolved}`);
+    }
+    return resolved;
+}

package/dist/agents/registry.js

@@ -0,0 +1,17 @@
+import { createClaudeSourceAdapter } from "./claude/adapter.js";
+import { createCodexSourceAdapter } from "./codex/adapter.js";
+const SOURCE_ADAPTERS = [
+    createCodexSourceAdapter(),
+    createClaudeSourceAdapter(),
+];
+const SOURCE_ADAPTER_BY_ID = new Map(SOURCE_ADAPTERS.map((adapter) => [adapter.source, adapter]));
+export function sourceAdapterById(source) {
+    const adapter = SOURCE_ADAPTER_BY_ID.get(source);
+    if (!adapter) {
+        throw new Error(`unsupported source: ${source}`);
+    }
+    return adapter;
+}
+export function supportedThreadSources() {
+    return [...SOURCE_ADAPTER_BY_ID.keys()];
+}

package/dist/agents/types.js

@@ -0,0 +1,2 @@
+export const RAW_ARTIFACT_VERSION = "threadlog.raw.v1";
+export const THREAD_SOURCES = ["codex", "claude"];

package/dist/codex/discovery.js

@@ -0,0 +1,63 @@
+import { readdir, stat } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export function codexHomeDir() {
+    const overridden = process.env.CODEX_HOME?.trim();
+    if (overridden) {
+        return path.resolve(overridden);
+    }
+    return path.join(os.homedir(), ".codex");
+}
+export async function discoverCodexRollouts(options) {
+    const sessionsRoot = options?.sessionsRoot
+        ? path.resolve(options.sessionsRoot)
+        : path.join(codexHomeDir(), "sessions");
+    const paths = await walkRolloutFiles(sessionsRoot);
+    const files = await Promise.all(paths.map(async (filePath) => {
+        const fileStats = await stat(filePath);
+        return {
+            filePath,
+            sizeBytes: fileStats.size,
+            mtimeMs: fileStats.mtimeMs,
+        };
+    }));
+    files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    if (!options?.maxResults || options.maxResults <= 0) {
+        return files;
+    }
+    return files.slice(0, options.maxResults);
+}
+async function walkRolloutFiles(rootDir) {
+    const pending = [rootDir];
+    const matches = [];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (!current) {
+            continue;
+        }
+        let entries;
+        try {
+            entries = await readdir(current, {
+                withFileTypes: true,
+                encoding: "utf8",
+            });
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                continue;
+            }
+            throw error;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                pending.push(fullPath);
+                continue;
+            }
+            if (entry.isFile() && entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl")) {
+                matches.push(fullPath);
+            }
+        }
+    }
+    return matches;
+}

package/dist/codex/metadata.js

@@ -0,0 +1,55 @@
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createInterface } from "node:readline";
+export async function readCodexRolloutMetadata(filePath) {
+    const fileStats = await stat(filePath);
+    let lineCount = 0;
+    let firstTimestamp = null;
+    let lastTimestamp = null;
+    const lineReader = createInterface({
+        input: createReadStream(filePath, { encoding: "utf8" }),
+        crlfDelay: Infinity,
+    });
+    for await (const rawLine of lineReader) {
+        const line = rawLine.trim();
+        if (!line) {
+            continue;
+        }
+        lineCount += 1;
+        const parsed = safeParse(line);
+        if (!parsed || typeof parsed !== "object") {
+            continue;
+        }
+        const timestamp = pickString(parsed, ["timestamp", "time"]);
+        if (!timestamp) {
+            continue;
+        }
+        if (!firstTimestamp) {
+            firstTimestamp = timestamp;
+        }
+        lastTimestamp = timestamp;
+    }
+    return {
+        lineCount,
+        firstTimestamp,
+        lastTimestamp,
+        sizeBytes: fileStats.size,
+    };
+}
+function safeParse(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function pickString(obj, keys) {
+    for (const key of keys) {
+        const value = obj[key];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return null;
+}