API 레퍼런스

class Deplite {
  Deplite({
    required String apiToken,
    String baseUrl = 'https://api.deplite.io/v1',
    http.Client? client,
  });
 
  static const String defaultBaseUrl = 'https://api.deplite.io/v1';
 
  final String apiToken;
  final String baseUrl;
 
  late final Triggers triggers;
  late final Files files;
 
  void close();
}

static Future<Enrollment> enroll({
  required String installCode,
  required String name,
  String? hostname,
  String? os,
  String? agentVersion,
  String baseUrl = 'https://api.deplite.io/v1',
  http.Client? client,
});

final enrollment = await Deplite.enroll(
  installCode: installCode,
  name: 'kiosk-seoul-01',
);
await secureStore.save(enrollment);   // identity + privateKey

Future<TriggerRunResult> run({
  required String triggerId,
  Object? params,
  String? workflowName,
  String? ref,
  bool debug = false,
  String? idempotencyKey,
});

final job = await deplite.triggers.run(
  triggerId: triggerId,
  params: {'ref': 'main', 'actor': 'sehyun'},
  idempotencyKey: 'release-${DateTime.now().millisecondsSinceEpoch}',
);
 
print('${job.jobId} ${job.status}');

Future<FileMeta> upload({
  required File file,
  CleanupRule cleanupRule = const TtlCleanup(86400),
  String? filename,
  String? contentType,
  String? bindingId,
});

final uploaded = await deplite.files.upload(
  file: File('/tmp/app.apk'),
  cleanupRule: const TtlCleanup(3600),
  contentType: 'application/vnd.android.package-archive',
);
 
await deplite.triggers.run(
  triggerId: triggerId,
  params: {'apkFileId': uploaded.id},
);

Future<PresignedUpload> presignUpload({
  required CleanupRule cleanupRule,
  String? filename,
  String? contentType,
  String? bindingId,
});

Future<FileMeta> completeUpload({required String fileId});
Future<String> downloadUrl({required String fileId});
Future<File> download({required String fileId, required File to});
Future<FileMeta> get({required String fileId});
Future<List<FileMeta>> list({String? bindingId, String? status});
Future<void> delete({required String fileId});

class DepliteAgent {
  DepliteAgent({
    required AgentIdentity identity,
    required Uint8List privateKey,    // 정확히 32바이트
    http.Client? client,
  });
 
  final AgentIdentity identity;
 
  late final AgentWorkflows workflows;
  late final AgentJobs jobs;
  late final AgentFiles files;
 
  void close();
}

Future<void> heartbeat();

Future<void> updateIdentity({
  String? hostname,
  String? os,
  String? agentVersion,
});

Stream<AgentEvent> events();

await for (final event in agent.events()) {
  switch (event) {
    case DeployEvent(payload: final p):
      await handleDeploy(p);
    case SyncWorkflowsEvent():
      await reportWorkflows();
    case RevokeEvent():
      return;
    case PingEvent():
      continue;
    case UnknownEvent(name: final n):
      print('unknown event: $n');
  }
}

Future<int> appendLogs({
  required String jobId,
  required List<LogItem> items,
});

Future<void> reportResult({
  required String jobId,
  required JobResult result,
});

try {
  final output = await runWorkflow(payload);
  await agent.jobs.reportResult(
    jobId: payload.jobId,
    result: JobResult.success(output: output),
  );
} catch (e) {
  await agent.jobs.reportResult(
    jobId: payload.jobId,
    result: JobResult.failed(exitCode: 1, errorMessage: '$e'),
  );
}

Future<FileMeta> upload({required String jobId, required File file, ...});
Future<PresignedUpload> presignUpload({required String jobId, ...});
Future<FileMeta> complete({required String fileId});
Future<String> downloadUrl({required String fileId});
Future<File> download({required String fileId, required File to});
Future<FileMeta> get({required String fileId});
Future<void> delete({required String fileId});

Future<int> report(List<WorkflowReport> workflows);

class Enrollment {
  const Enrollment({
    required this.identity,
    required this.privateKey,        // raw 32-byte 개인키
  });
  final AgentIdentity identity;
  final Uint8List privateKey;
}

class AgentIdentity {
  const AgentIdentity({
    required this.agentId,
    required this.organizationId,
    required this.baseUrl,
    required this.serverPublicKeyPem,
  });
 
  final String agentId;
  final String organizationId;
  final String baseUrl;
  final String serverPublicKeyPem;
 
  Map<String, dynamic> toJson();
  factory AgentIdentity.fromJson(Map<String, dynamic> json);
}

sealed class AgentEvent { const AgentEvent(); }
 
class DeployEvent extends AgentEvent {
  const DeployEvent(this.payload, this.signature);
  final DeployPayload payload;
  final String signature;
}
 
class RevokeEvent          extends AgentEvent { const RevokeEvent(); }
class SyncWorkflowsEvent   extends AgentEvent { const SyncWorkflowsEvent(); }
class PingEvent            extends AgentEvent { const PingEvent(); }
 
class UnknownEvent extends AgentEvent {
  const UnknownEvent(this.name, this.data);
  final String name;
  final String data;
}

class DeployPayload {
  const DeployPayload({
    required this.jobId,
    required this.workflowName,
    this.debug = false,
    this.ref,
    this.params,
    this.issuedAt = 0,
    this.nonce = '',
    this.force = false,
    this.forceReason,
  });
 
  final String jobId;
  final String workflowName;
  final bool debug;
  final String? ref;
  final Object? params;
  final int issuedAt;
  final String nonce;
  final bool force;
  final String? forceReason;
}

class TriggerRunResult {
  const TriggerRunResult({
    required this.jobId,
    required this.status,
    this.idempotent = false,
    this.timedOut = false,
    this.exitCode,
    this.errorMessage,
    this.output,
    this.statusUrl,
  });
 
  final String jobId;
  final String status;
  final bool idempotent;
  final bool timedOut;
  final int? exitCode;
  final String? errorMessage;
  final Object? output;
  final String? statusUrl;
}

sealed class CleanupRule {
  const CleanupRule();
  String get wireValue;
}
 
class TtlCleanup extends CleanupRule {
  const TtlCleanup(this.ttlSeconds);          // 60s ≤ ttl ≤ 90일
  final int ttlSeconds;
}
 
class PersistentCleanup extends CleanupRule {
  const PersistentCleanup();
}
 
class OnJobEndCleanup extends CleanupRule {   // Agent Files 전용
  const OnJobEndCleanup();
}

class FileMeta {
  const FileMeta({
    required this.id,
    this.bindingId,
    this.jobId,
    this.filename,
    this.contentType,
    this.size,
    this.status,
    this.cleanupRule,
    this.expiresAt,
    this.createdAt,
  });
 
  final String id;
  final String? bindingId;
  final String? jobId;
  final String? filename;
  final String? contentType;
  final int? size;
  final String? status;
  final String? cleanupRule;
  final String? expiresAt;
  final String? createdAt;
}

class PresignedUpload {
  const PresignedUpload({
    required this.fileId,
    required this.uploadUrl,
    this.uploadHeaders,
    this.expiresInSeconds,
  });
 
  final String fileId;
  final Uri uploadUrl;
  final Map<String, String>? uploadHeaders;
  final int? expiresInSeconds;
}

enum LogStream { raw, system }
enum LogLevel  { info, warn, error }
 
class LogItem {
  const LogItem({
    required this.seq,
    required this.stream,
    required this.content,
    this.stepName,
    this.level,
  });
 
  final int seq;
  final LogStream stream;
  final String content;
  final String? stepName;
  final LogLevel? level;
}

enum JobStatus { running, success, failed, timeout, rejected }
 
class JobResult {
  final JobStatus status;
  final int? exitCode;
  final String? errorMessage;
  final Object? output;
  final Rejection? rejection;
 
  factory JobResult.running();
  factory JobResult.success({int exitCode = 0, Object? output});
  factory JobResult.failed({int? exitCode, String? errorMessage});
  factory JobResult.timeout({String? errorMessage});
  factory JobResult.rejected(Rejection rejection);
}

class Rejection {
  const Rejection({
    required this.reason,
    this.limitType,
    this.retryAfterSeconds,
    this.bypassedLimits = const <String>[],
  });
 
  final String reason;
  final String? limitType;
  final int? retryAfterSeconds;
  final List<String> bypassedLimits;
}

class WorkflowReport {
  const WorkflowReport({
    required this.name,
    this.verboseSteps = const <String>[],
    this.secretsKeys = const <String>[],
  });
 
  final String name;
  final List<String> verboseSteps;
  final List<String> secretsKeys;
 
  Map<String, dynamic> toJson();
}

class DepliteException implements Exception {
  DepliteException(this.message, {this.cause});
  final String message;
  final Object? cause;
}

class DepliteApiException extends DepliteException {
  DepliteApiException(this.statusCode, this.body);
  final int statusCode;
  final String body;
}

class DepliteAuthException extends DepliteApiException {
  DepliteAuthException(int statusCode, String body) : super(statusCode, body);
}

try {
  await deplite.triggers.run(triggerId: triggerId, params: {});
} on DepliteAuthException {
  // 토큰 회수·교체 필요
} on DepliteApiException catch (e) {
  if (e.statusCode == 429 || e.statusCode >= 500) {
    // 백오프 후 재시도
  }
} on DepliteException catch (e) {
  print('${e.message} ${e.cause}');
}