deepline 0.1.12 → 0.1.20

package/dist/repo/sdk/src/cli/skills-sync.ts

@@ -1,141 +0,0 @@
-import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { getActiveCliProgress } from './progress.js';
-import { baseUrlSlug } from '../config.js';
-
-const CHECK_TIMEOUT_MS = 3_000;
-const SDK_SKILL_NAME = 'deepline-sdk';
-const SKILL_AGENTS = ['codex', 'claude-code', 'cursor'] as const;
-
-type UpdateCheckResponse = {
-  skills?: {
-    needs_update?: unknown;
-    remote?: {
-      version?: unknown;
-    };
-  };
-};
-
-let attemptedSync = false;
-
-function shouldSkipSkillsSync(): boolean {
-  const value = process.env.DEEPLINE_SKIP_SKILLS_SYNC?.trim().toLowerCase();
-  return value === '1' || value === 'true' || value === 'yes' || value === 'on';
-}
-
-function sdkSkillsVersionPath(baseUrl: string): string {
-  const home = process.env.HOME?.trim() || homedir();
-  return join(home, '.local', 'deepline', baseUrlSlug(baseUrl), 'sdk-skills', '.version');
-}
-
-function readLocalSkillsVersion(baseUrl: string): string {
-  const path = sdkSkillsVersionPath(baseUrl);
-  if (!existsSync(path)) return '';
-  try {
-    return readFileSync(path, 'utf-8').trim();
-  } catch {
-    return '';
-  }
-}
-
-function writeLocalSkillsVersion(baseUrl: string, version: string): void {
-  const path = sdkSkillsVersionPath(baseUrl);
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${version}\n`, 'utf-8');
-}
-
-async function fetchSkillsUpdate(baseUrl: string, localVersion: string): Promise<{
-  needsUpdate: boolean;
-  remoteVersion: string;
-} | null> {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
-  try {
-    const response = await fetch(new URL('/api/v2/cli/update-check', baseUrl), {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        skills: {
-          version: localVersion,
-        },
-      }),
-      signal: controller.signal,
-    });
-    if (!response.ok) return null;
-    const data = (await response.json().catch(() => null)) as UpdateCheckResponse | null;
-    const skills = data?.skills;
-    if (!skills) return null;
-    return {
-      needsUpdate: skills.needs_update === true,
-      remoteVersion: typeof skills.remote?.version === 'string' ? skills.remote.version.trim() : '',
-    };
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-function runSkillsInstall(baseUrl: string): Promise<boolean> {
-  const packageUrl = new URL('/.well-known/skills/index.json', baseUrl).toString();
-  const args = [
-    'skills',
-    'add',
-    packageUrl,
-    '--agents',
-    ...SKILL_AGENTS,
-    '--global',
-    '--yes',
-    '--skill',
-    SDK_SKILL_NAME,
-    '--full-depth',
-  ];
-
-  return new Promise((resolve) => {
-    const child = spawn('npx', args, {
-      stdio: ['ignore', 'ignore', 'pipe'],
-      env: process.env,
-    });
-    let stderr = '';
-    child.stderr.on('data', (chunk: Buffer) => {
-      stderr += chunk.toString('utf-8');
-    });
-    child.on('error', (error) => {
-      process.stderr.write(`SDK skills sync failed to start: ${error.message}\n`);
-      resolve(false);
-    });
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve(true);
-        return;
-      }
-      const detail = stderr.trim();
-      process.stderr.write(
-        `SDK skills sync failed${detail ? `: ${detail}` : ''}\n` +
-          `Run manually: npx ${args.map((arg) => (arg.includes(' ') ? JSON.stringify(arg) : arg)).join(' ')}\n`,
-      );
-      resolve(false);
-    });
-  });
-}
-
-export async function syncSdkSkillsIfNeeded(baseUrl: string): Promise<void> {
-  if (attemptedSync || shouldSkipSkillsSync()) return;
-  attemptedSync = true;
-
-  const localVersion = readLocalSkillsVersion(baseUrl);
-  const update = await fetchSkillsUpdate(baseUrl, localVersion);
-  if (!update?.needsUpdate || !update.remoteVersion) return;
-
-  const progress = getActiveCliProgress();
-  progress?.writeLine('SDK skills changed; syncing deepline-sdk skill...') ??
-    process.stderr.write('SDK skills changed; syncing deepline-sdk skill...\n');
-  const installed = await runSkillsInstall(baseUrl);
-  if (!installed) return;
-
-  writeLocalSkillsVersion(baseUrl, update.remoteVersion);
-  progress?.writeLine('SDK skills are up to date.') ??
-    process.stderr.write('SDK skills are up to date.\n');
-}

package/dist/repo/sdk/src/cli/trace.ts

@@ -1,61 +0,0 @@
-type CliTraceFields = Record<string, unknown>;
-
-type CliTraceEvent = CliTraceFields & {
-  phase: string;
-  ms?: number;
-  ok?: boolean;
-};
-
-const cliTraceStartedAt = Date.now();
-
-function isTruthyEnv(value: string | undefined): boolean {
-  return value === '1' || value === 'true' || value === 'yes';
-}
-
-export function isCliTraceEnabled(): boolean {
-  return isTruthyEnv(process.env.DEEPLINE_CLI_TRACE);
-}
-
-export function recordCliTrace(event: CliTraceEvent): void {
-  if (!isCliTraceEnabled()) {
-    return;
-  }
-  const now = Date.now();
-  const payload = {
-    ts: now,
-    source: 'cli',
-    sinceStartMs: now - cliTraceStartedAt,
-    ...event,
-  };
-  process.stderr.write(`[cli-trace] ${JSON.stringify(payload)}\n`);
-}
-
-export async function traceCliSpan<T>(
-  phase: string,
-  fields: CliTraceFields,
-  run: () => Promise<T>,
-): Promise<T> {
-  if (!isCliTraceEnabled()) {
-    return run();
-  }
-  const startedAt = Date.now();
-  try {
-    const result = await run();
-    recordCliTrace({
-      phase,
-      ms: Date.now() - startedAt,
-      ok: true,
-      ...fields,
-    });
-    return result;
-  } catch (error) {
-    recordCliTrace({
-      phase,
-      ms: Date.now() - startedAt,
-      ok: false,
-      error: error instanceof Error ? error.message : String(error),
-      ...fields,
-    });
-    throw error;
-  }
-}

package/dist/repo/sdk/src/cli/utils.ts

@@ -1,145 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { execSync } from 'node:child_process';
-import { parse } from 'csv-parse/sync';
-import { stringify } from 'csv-stringify/sync';
-import { resolveConfig } from '../config.js';
-import { HttpClient } from '../http.js';
-
-export function getAuthedHttpClient() {
-  const config = resolveConfig();
-  return { config, http: new HttpClient(config) };
-}
-
-export async function writeOutputFile(
-  filename: string,
-  content: string,
-): Promise<string> {
-  const outputDir = resolve(process.cwd(), 'deepline', 'data');
-  await mkdir(outputDir, { recursive: true });
-  const fullPath = join(outputDir, filename);
-  await writeFile(fullPath, content, 'utf-8');
-  return fullPath;
-}
-
-export function openInBrowser(url: string): void {
-  try {
-    if (process.platform === 'darwin') execSync(`open "${url}"`, { stdio: 'ignore' });
-    else if (process.platform === 'win32')
-      execSync(`start "" "${url}"`, { stdio: 'ignore' });
-    else execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
-  } catch {
-    // best effort
-  }
-}
-
-export function sleep(ms: number): Promise<void> {
-  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
-}
-
-export function collectLocalEnvInfo(): Record<string, string> {
-  return {
-    os: `${process.platform} ${process.arch}`,
-    node_version: process.version,
-    home_dir: homedir(),
-  };
-}
-
-export function readCsvRows(csvPath: string): Array<Record<string, string>> {
-  const raw = readFileSync(resolve(csvPath), 'utf-8');
-  return parse(raw, {
-    columns: true,
-    skip_empty_lines: true,
-  }) as Array<Record<string, string>>;
-}
-
-export function csvStringFromRows(
-  rows: Array<Record<string, unknown>>,
-  columns?: string[],
-): string {
-  return stringify(rows, {
-    header: true,
-    ...(columns?.length ? { columns } : {}),
-  });
-}
-
-export function printJson(value: unknown): void {
-  process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
-}
-
-export function errorToJsonPayload(error: unknown): {
-  ok: false;
-  error: {
-    message: string;
-    code: string;
-    details?: Record<string, unknown>;
-  };
-} {
-  const message = error instanceof Error ? error.message : String(error);
-  const maybeRecord =
-    error && typeof error === 'object'
-      ? (error as Record<string, unknown>)
-      : null;
-  const code =
-    typeof maybeRecord?.code === 'string'
-      ? maybeRecord.code
-      : error instanceof SyntaxError
-        ? 'INVALID_JSON'
-        : 'CLI_ERROR';
-  const details: Record<string, unknown> = {};
-  if (typeof maybeRecord?.statusCode === 'number') {
-    details.statusCode = maybeRecord.statusCode;
-  }
-  if (typeof maybeRecord?.status === 'number') {
-    details.status = maybeRecord.status;
-  }
-  if (
-    maybeRecord?.details &&
-    typeof maybeRecord.details === 'object' &&
-    !Array.isArray(maybeRecord.details)
-  ) {
-    details.details = maybeRecord.details;
-  }
-  if (typeof maybeRecord?.cause === 'string') {
-    details.cause = maybeRecord.cause;
-  }
-  return {
-    ok: false,
-    error: {
-      message,
-      code,
-      ...(Object.keys(details).length > 0 ? { details } : {}),
-    },
-  };
-}
-
-export function printJsonError(error: unknown): void {
-  printJson(errorToJsonPayload(error));
-}
-
-export function shouldEmitJson(explicitJson = false): boolean {
-  return explicitJson || !process.stdout.isTTY;
-}
-
-export function argsWantJson(args: string[]): boolean {
-  return shouldEmitJson(args.includes('--json'));
-}
-
-export function createTimestampedName(prefix: string, extension: string): string {
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  return `${prefix}-${timestamp}.${extension}`;
-}
-
-export async function writeCsvRowsFile(
-  prefix: string,
-  rows: Array<Record<string, unknown>>,
-): Promise<string> {
-  const path = await writeOutputFile(createTimestampedName(prefix, 'csv'), csvStringFromRows(rows));
-  return path;
-}
-
-export function clip(value: string, maxLength: number): string {
-  return value.length > maxLength ? `${value.slice(0, maxLength - 1)}…` : value;
-}

package/dist/repo/sdk/src/compat.ts

@@ -1,77 +0,0 @@
-import { SDK_API_CONTRACT, SDK_VERSION } from "./version.js";
-
-export type SdkCompatibilityStatus =
-  | "current"
-  | "update_available"
-  | "deprecated"
-  | "unsupported";
-
-export type SdkCompatibilityResponse = {
-  ok: boolean;
-  status: SdkCompatibilityStatus;
-  current: string | null;
-  latest: string;
-  minimum_supported: string;
-  deprecated_below: string;
-  api_contract: string;
-  update_available: boolean;
-  update_required: boolean;
-  message: string;
-  update_command: string;
-};
-
-const CHECK_TIMEOUT_MS = 2_000;
-
-function shouldSkipCompatibilityCheck(): boolean {
-  const value = process.env.DEEPLINE_SKIP_SDK_COMPAT_CHECK?.trim().toLowerCase();
-  return value === "1" || value === "true" || value === "yes";
-}
-
-export async function checkSdkCompatibility(baseUrl: string): Promise<{
-  response: SdkCompatibilityResponse | null;
-  error: Error | null;
-}> {
-  if (shouldSkipCompatibilityCheck()) {
-    return { response: null, error: null };
-  }
-
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
-  try {
-    const url = new URL("/api/v2/sdk/compat", baseUrl);
-    url.searchParams.set("version", SDK_VERSION);
-    const response = await fetch(url, {
-      method: "GET",
-      headers: {
-        "User-Agent": `deepline-ts-sdk/${SDK_VERSION}`,
-        "X-Deepline-SDK-Version": SDK_VERSION,
-        "X-Deepline-API-Contract": SDK_API_CONTRACT,
-      },
-      signal: controller.signal,
-    });
-    const data = (await response.json().catch(() => null)) as
-      | SdkCompatibilityResponse
-      | null;
-    return { response: data, error: null };
-  } catch (error) {
-    return {
-      response: null,
-      error: error instanceof Error ? error : new Error(String(error)),
-    };
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-export async function enforceSdkCompatibility(baseUrl: string): Promise<void> {
-  const { response, error } = await checkSdkCompatibility(baseUrl);
-  if (error || !response) {
-    return;
-  }
-  if (response.update_required) {
-    throw new Error(response.message);
-  }
-  if (response.status === "deprecated" || response.status === "update_available") {
-    process.stderr.write(`${response.message}\n`);
-  }
-}

package/dist/repo/shared_libs/observability/node-tracing.ts

@@ -1,129 +0,0 @@
-import { mkdir, appendFile } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import type { NodeSDK } from '@opentelemetry/sdk-node';
-import type {
-  ReadableSpan,
-  SpanExporter,
-} from '@opentelemetry/sdk-trace-base';
-import type { ExportResult } from '@opentelemetry/core';
-
-const EXPORT_RESULT_SUCCESS = 0;
-const EXPORT_RESULT_FAILED = 1;
-
-declare global {
-  var __deeplineTracingInitPromise: Promise<boolean> | undefined;
-  var __deeplineTracingSdk: NodeSDK | undefined;
-  var __deeplineTracingShutdownPromise: Promise<void> | undefined;
-}
-
-class JsonlFileSpanExporter implements SpanExporter {
-  constructor(private readonly filePath: string) {}
-
-  async export(
-    spans: ReadableSpan[],
-    resultCallback: (result: ExportResult) => void,
-  ): Promise<void> {
-    try {
-      await mkdir(dirname(this.filePath), { recursive: true });
-      const lines = spans
-        .map((span) =>
-          JSON.stringify({
-            traceId: span.spanContext().traceId,
-            spanId: span.spanContext().spanId,
-            parentSpanId: span.parentSpanContext?.spanId ?? null,
-            name: span.name,
-            kind: span.kind,
-            startTime: span.startTime,
-            endTime: span.endTime,
-            attributes: span.attributes,
-            status: span.status,
-            resource: span.resource.attributes,
-          }),
-        )
-        .join('\n');
-      if (lines.length > 0) {
-        await appendFile(this.filePath, `${lines}\n`, 'utf-8');
-      }
-      resultCallback({ code: EXPORT_RESULT_SUCCESS });
-    } catch (error) {
-      resultCallback({
-        code: EXPORT_RESULT_FAILED,
-        error: error instanceof Error ? error : new Error(String(error)),
-      });
-    }
-  }
-
-  async shutdown(): Promise<void> {}
-  async forceFlush(): Promise<void> {}
-}
-
-async function resolveTraceExporters(): Promise<SpanExporter[]> {
-  const exporters: SpanExporter[] = [];
-  const otlpEndpoint =
-    process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT?.trim() ||
-    process.env.OTEL_EXPORTER_OTLP_ENDPOINT?.trim() ||
-    '';
-  if (otlpEndpoint) {
-    const { OTLPTraceExporter } = await import(
-      '@opentelemetry/exporter-trace-otlp-http'
-    );
-    exporters.push(new OTLPTraceExporter());
-  }
-
-  const traceFilePath = process.env.DEEPLINE_TRACE_FILE?.trim() || '';
-  if (traceFilePath) {
-    exporters.push(new JsonlFileSpanExporter(traceFilePath));
-  }
-
-  return exporters;
-}
-
-async function startNodeTracing(serviceName: string): Promise<boolean> {
-  const exporters = await resolveTraceExporters();
-  if (exporters.length === 0) {
-    return false;
-  }
-
-  if (!process.env.OTEL_SERVICE_NAME) {
-    process.env.OTEL_SERVICE_NAME = serviceName;
-  }
-
-  const [{ NodeSDK }, { BatchSpanProcessor }] = await Promise.all([
-    import('@opentelemetry/sdk-node'),
-    import('@opentelemetry/sdk-trace-base'),
-  ]);
-
-  const sdk = new NodeSDK({
-    instrumentations: [],
-    spanProcessors: exporters.map(
-      (exporter) => new BatchSpanProcessor(exporter),
-    ),
-  });
-  await sdk.start();
-  globalThis.__deeplineTracingSdk = sdk;
-  return true;
-}
-
-export async function ensureNodeTracing(serviceName: string): Promise<boolean> {
-  globalThis.__deeplineTracingInitPromise ??= startNodeTracing(serviceName);
-  return await globalThis.__deeplineTracingInitPromise;
-}
-
-export async function shutdownNodeTracing(): Promise<void> {
-  const initialized = await (globalThis.__deeplineTracingInitPromise ??
-    Promise.resolve(false));
-  if (!initialized) {
-    return;
-  }
-
-  const sdk = globalThis.__deeplineTracingSdk;
-  if (!sdk) {
-    return;
-  }
-
-  globalThis.__deeplineTracingShutdownPromise ??= sdk.shutdown().finally(() => {
-    globalThis.__deeplineTracingSdk = undefined;
-    globalThis.__deeplineTracingInitPromise = undefined;
-  });
-  await globalThis.__deeplineTracingShutdownPromise;
-}

package/dist/repo/shared_libs/observability/tracing.ts

@@ -1,98 +0,0 @@
-import {
-  SpanKind,
-  SpanStatusCode,
-  trace,
-  type Attributes,
-  type Span,
-} from '@opentelemetry/api';
-
-type PrimitiveAttribute =
-  | string
-  | number
-  | boolean
-  | null
-  | undefined;
-
-type TraceAttributes = Record<string, PrimitiveAttribute>;
-
-function normalizeAttributes(
-  attributes: TraceAttributes | undefined,
-): Attributes | undefined {
-  if (!attributes) {
-    return undefined;
-  }
-
-  const normalized: Attributes = {};
-  for (const [key, value] of Object.entries(attributes)) {
-    if (value === undefined || value === null) {
-      continue;
-    }
-    if (
-      typeof value === 'string' ||
-      typeof value === 'number' ||
-      typeof value === 'boolean'
-    ) {
-      normalized[key] = value;
-    }
-  }
-  return Object.keys(normalized).length > 0 ? normalized : undefined;
-}
-
-function recordError(span: Span, error: unknown): void {
-  if (error instanceof Error) {
-    span.recordException(error);
-    span.setStatus({
-      code: SpanStatusCode.ERROR,
-      message: error.message,
-    });
-    return;
-  }
-
-  const message = String(error);
-  span.recordException({ name: 'Error', message });
-  span.setStatus({
-    code: SpanStatusCode.ERROR,
-    message,
-  });
-}
-
-export async function withActiveSpan<T>(
-  name: string,
-  options: {
-    tracer?: string;
-    kind?: SpanKind;
-    attributes?: TraceAttributes;
-  },
-  fn: (span: Span) => Promise<T> | T,
-): Promise<T> {
-  const tracer = trace.getTracer(options.tracer ?? 'deepline');
-  return await tracer.startActiveSpan(
-    name,
-    {
-      kind: options.kind,
-      attributes: normalizeAttributes(options.attributes),
-    },
-    async (span) => {
-      try {
-        const result = await fn(span);
-        span.setStatus({ code: SpanStatusCode.OK });
-        return result;
-      } catch (error) {
-        recordError(span, error);
-        throw error;
-      } finally {
-        span.end();
-      }
-    },
-  );
-}
-
-export function setSpanAttributes(
-  span: Span,
-  attributes: TraceAttributes,
-): void {
-  const normalized = normalizeAttributes(attributes);
-  if (normalized) {
-    span.setAttributes(normalized);
-  }
-}